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)))); }