private static bool CompareElement <T>(T track, PredicateString <T> pre, SearchMethods method,
string[] searchstring)
{
switch (method)
{
case SearchMethods.ContainsAny:
for (int i = 0; i < searchstring.Length; i++)
{
if (pre(track, searchstring[i]))
{
return(true);
}
}
return(false);
case SearchMethods.ContainsAll:
for (int i = 0; i < searchstring.Length; i++)
{
if (!pre(track, searchstring[i]))
{
return(false);
}
}
return(true);
default:
throw new InvalidOperationException("Unknown search method.");
}
}
public static IEnumerable <T> Search <T>(this IEnumerable <T> list, PredicateString <T> predicate,
SearchMethods method, params string[] searchstring)
{
string[] search = searchstring;
for (int i = 0; i < search.Length; i++)
{
search[i] = search[i].ToLower();
}
if (search.Length == 0)
{
foreach (T element in list)
{
yield return(element);
}
}
else
{
foreach (T element in list)
{
if (CompareElement(element, predicate, method, search))
{
yield return(element);
}
}
}
}
public IReducedClassCollection HasName(Expression <Predicate <string> > nameFilterExpression)
{
var nameFilter = nameFilterExpression.Compile();
PredicateString.Add($"has name matching '{nameFilterExpression}'");
return(AppendCondition(c => nameFilter(c.Name)));
}
public IReducedClassCollection IsDerivedFrom(Type type)
{
PredicateString.Add($"is derived from {type}");
var predicate = CreateClassPredicate(type);
return(AppendCondition(c => predicate(c.ClassType)));
}
public IInterfaceRule IsDeclaredInAssembly(Expression <Predicate <Assembly> > assemblyMatchingExpression)
{
PredicateString.Add($"is declared in assembly '{assemblyMatchingExpression}'");
var assemblyMatcher = assemblyMatchingExpression.Compile();
return(AppendCondition(c => assemblyMatcher(c.AssemblyInfo.Assembly.Assembly)));
}
public IInterfaceRule Is(Expression <Predicate <Type> > typeExpression)
{
PredicateString.Add($"is declared in assembly '{typeExpression}'");
var typeMatcher = typeExpression.Compile();
return(AppendCondition(c => typeMatcher(c.ClassType)));
}
public IClassRule Be(Expression <Predicate <Type> > typeFilterExpression)
{
PredicateString.Add($"be {typeFilterExpression}");
var typePredicate = typeFilterExpression.Compile();
return(AppendCondition(c => typePredicate(c.ClassType)));
}
public IAssemblyRule HaveName(Expression <Predicate <string> > nameFilterExpression)
{
PredicateString.Add($"have name matching {nameFilterExpression}");
var nameFilter = nameFilterExpression.Compile();
return(AppendCondition(r => nameFilter(r.Name)));
}
public IClassRule HaveName(Expression <Predicate <string> > nameFilterExpression)
{
PredicateString.Add($"have a name matching '{nameFilterExpression}'");
var nameFilter = nameFilterExpression.Compile();
return(AppendCondition(c => nameFilter(c.Name)));
}
public IClassRule BeInAssembly(Expression <Predicate <Assembly> > assemblyFilterExpression)
{
PredicateString.Add($"be in an assembly matching '{assemblyFilterExpression}'");
var filter = assemblyFilterExpression.Compile();
return(AppendCondition(c => filter(c.AssemblyInfo.Assembly.Assembly)));
}
public IClassMatchingInterfaceRule IsDeclaredInAssembly(Expression <Predicate <Assembly> > predicateExpression)
{
PredicateString.Add($"is declared in an assembly matching '{predicateExpression}'");
var predicate = predicateExpression.Compile();
return(InnerAppendCondition((c, i) => predicate(i.Assembly)));
}
public IClassMatchingInterfaceRule Is(Expression <Predicate <Type> > typeExpressionExpression)
{
PredicateString.Add($"is '{typeExpressionExpression}'");
var typeFilter = typeExpressionExpression.Compile();
return(InnerAppendCondition((c, i) => typeFilter(i)));
}
public IClassMatchingInterfaceRule HasName(Expression <Predicate <string> > nameFilterExpression)
{
PredicateString.Add($"has name matching '{nameFilterExpression}'");
var nameFilter = nameFilterExpression.Compile();
return(InnerAppendCondition((c, i) => nameFilter(i.Name)));
}
public IClassMatchingInterfaceRule HasMatchingName(Expression <Func <Type, string> > typeFilterExpression)
{
PredicateString.Add($"has matching name {typeFilterExpression}");
var classNameMatcher = typeFilterExpression.Compile();
return(InnerAppendCondition((c, i) => i.Name.Matches(classNameMatcher(c.ClassType))));
}
public IInterfaceRule HasName(Expression <Predicate <string> > nameFilterExpression)
{
PredicateString.Add($"has name ({nameFilterExpression})");
var nameFilter = nameFilterExpression.Compile();
return(AppendCondition(c => nameFilter(c.Name)));
}
public IAssemblyRule ReferenceAssembliesMatching(Expression <Predicate <IAssemblyInfo> > assemblyFilterExpression)
{
PredicateString.Add($"reference assemblies matching '{assemblyFilterExpression}'");
var assemblyFilter = assemblyFilterExpression.Compile();
return(AppendCondition(a => a.ReferencedAssemblies.Any(r => assemblyFilter(r))));
}
public IReducedClassCollection IsDeclaredInAssembly(Expression <Predicate <Assembly> > assemblyFilterExpression)
{
var predicate = assemblyFilterExpression.Compile();
PredicateString.Add($"is declared in an assembly matching '{assemblyFilterExpression}'");
return(AppendCondition(c => predicate(c.AssemblyInfo.Assembly.Assembly)));
}
private IAssemblyCollection ThatOrWhich(string word)
{
PredicateString.Add(word);
var assemblies = _assemblyCollector.Get();
var assemblyFilter = new FilteredAssemblies(assemblies);
var result = new AssemblyCollection(assemblyFilter, _negate);
return(_not ? result.Not() : result);
}
public static IEnumerable <T> Search <T>(this IEnumerable <T> list, PredicateString <T> predicate,
SearchMethods method, string searchstring)
{
return(Search(list, predicate, method, SplitString(searchstring)));
}
public static IEnumerable <T> Search <T, R>(this IEnumerable <T> list, Converter <T, R> convert,
PredicateString <R> predicate, SearchMethods method, params string[] searchstring)
{
return(Search(list, (t, s) => predicate(convert(t), s), method, searchstring));
}
public static IEnumerable <T> Search <T>(this IPlaylist <T> playlist, PredicateString <T> predicate,
SearchMethods method, params string[] searchstring)
{
return(Search(playlist, t => t, predicate, method, searchstring));
}
public IReducedAssemblyCollection HasNameMatching(string pattern)
{
PredicateString.Add($"has name matching '{pattern}'");
return(InnerHasName(n => n.Matches(pattern)));
}
private IClassCollection ThatOrWhich(string word)
{
PredicateString.Add(word);
return(_classCollectionFactory.Create(_classCollector, _negate, _not));
}
public IReducedClassCollection ImplementsInterfaceMatching(string pattern)
{
PredicateString.Add($"implements an interface matching '{pattern}'");
return(AppendCondition(c => c.ClassType.GetInterfaces().Any(i => i.Name.Matches(pattern))));
}
public IAssemblyRule ReferenceAssembliesMatching(string pattern)
{
PredicateString.Add($"reference assemblies matching '{pattern}'");
return(AppendCondition(r => r.ReferencedAssemblies.Any(x => x.Name.Matches(pattern))));
}
public IAssemblyRule ReferenceAssembly(string name)
{
PredicateString.Add($"reference assembly '{name}'");
return(AppendCondition(r => r.ReferencedAssemblies.Any(x => x.Name == name)));
}
public IReducedAssemblyCollection HasName(Expression <Predicate <string> > nameFilter)
{
PredicateString.Add($"has name matching {nameFilter}");
return(InnerHasName(nameFilter.Compile()));
}
public IReducedClassCollection Is(Expression <Predicate <Type> > typeExpression)
{
PredicateString.Add($"Is {typeExpression}");
return(AppendCondition(c => typeExpression.Compile()(c.ClassType)));
}
private IClassMatchingInterfaceCondition WhichOrThat(string word)
{
PredicateString.Add(word);
return(_classMatchingInterfaceCondition);
}
public IReducedClassCollection HasAttribute <TAttribute>()
where TAttribute : Attribute
{
PredicateString.Add($"has attribute '{typeof(TAttribute).Name}'");
return(AppendCondition(c => ClassHasAttribute(c.ClassType, typeof(TAttribute))));
}
