/** * Make sure the passed extension matches all filters. * * @param filters the filters * @param extension the extension to match * @return false if one of the filter is not matching the extension * @since 8.3RC1 */ public static boolean matches(Collection<Filter> filters, Extension extension) { if (filters != null) { for (Filter filter : filters) { if (!matches(filter, extension)) { return false; } } } return true; }
/** * Matches a set of elements in a case insensitive way. * * @param patternMatcher the pattern to match * @param elements the elements to match * @return true if one of the element is matched */ public static boolean matches(Pattern patternMatcher, Object... elements) { if (patternMatcher == null) { return true; } for (Object element : elements) { if (matches(patternMatcher, element)) { return true; } } return false; }
/** * @param pattern the pattern to match * @param filters the filters * @param extensions the extension collection to search in * @param forceUnique make sure returned elements are unique * @return the filtered list of extensions * @since 7.0M2 * @param <E> the type of element in the {@link Collection} */ private static <E extends Extension> List<E> filter(String pattern, Collection<Filter> filters, Collection<E> extensions, boolean forceUnique) { List<E> result = new ArrayList<>(extensions.size()); Pattern patternMatcher = Pattern.compile(SEARCH_PATTERN_SUFFIXNPREFIX + pattern.toLowerCase() + SEARCH_PATTERN_SUFFIXNPREFIX); for (E extension : extensions) { if (matches(patternMatcher, filters, extension)) { result.add(extension); } } // Make sure all the elements of the list are unique if (forceUnique && result.size() > 1) { result = new ArrayList<>(new LinkedHashSet<>(result)); } return result; }
/** * @param filter the filter * @param extension the extension to match * @return true if the extension is matched by the filer * @since 7.0M2 */ public static boolean matches(Filter filter, Extension extension) { return matches(filter, extension.<Object>get(filter.getField())); }
@Override public Extension resolve(ExtensionId extensionId) throws ResolveException { for (ExtensionRepository remoteRepository : this.repositories.getRepositories()) { Extension extension = remoteRepository.resolve(extensionId); if (extension != null && RepositoryUtils.matches(this.filters, extension)) { return extension; } } return null; }
@Override public Extension resolve(ExtensionDependency extensionDependency) throws ResolveException { for (ExtensionRepository remoteRepository : this.repositories.getRepositories()) { Extension extension = remoteRepository.resolve(extensionDependency); if (extension != null && RepositoryUtils.matches(this.filters, extension)) { return extension; } } return null; }
protected List<InstalledExtension> filter(Collection<String> namespaces, ExtensionQuery query, Collection<? extends InstalledExtension> installedExtensions) { Pattern patternMatcher = RepositoryUtils.createPatternMatcher(query.getQuery()); List<InstalledExtension> result = new ArrayList<>(installedExtensions.size()); for (InstalledExtension installedExtension : installedExtensions) { if (namespaces == null || namespaces.isEmpty()) { if (RepositoryUtils.matches(patternMatcher, query.getFilters(), installedExtension)) { result.add(installedExtension); } } else { for (String namespace : namespaces) { if (installedExtension.isInstalled(namespace)) { if (RepositoryUtils.matches(patternMatcher, query.getFilters(), installedExtension)) { result.add(installedExtension); } } } } } return result; } }
@Override public IterableResult<Extension> search(ExtensionQuery query) { Pattern patternMatcher = RepositoryUtils.createPatternMatcher(query.getQuery()); Set<Extension> set = new HashSet<Extension>(); List<Extension> result = new ArrayList<Extension>(this.extensionsVersions.size()); for (List<E> versions : this.extensionsVersions.values()) { E extension = versions.get(0); if (RepositoryUtils.matches(patternMatcher, query.getFilters(), extension) && !set.contains(extension)) { result.add(extension); set.add(extension); } } // Sort RepositoryUtils.sort(result, query.getSortClauses()); return RepositoryUtils.getIterableResult(query.getOffset(), query.getLimit(), result); } }
/** * @param filter the filter * @param element the element to match * @return true if the element is matched by the filer * @since 7.0M2 */ public static boolean matches(Filter filter, Object element) { if (element == null) { return filter.getValue() == null; } else if (filter.getValue() == null) { return false; } // TODO: add support for more than String String filterValue = String.valueOf(filter.getValue()); String elementValue = String.valueOf(element); if (filter.getComparison() == COMPARISON.MATCH) { Pattern patternMatcher = createPatternMatcher(filterValue); if (matches(patternMatcher, elementValue)) { return true; } } else if (filter.getComparison() == COMPARISON.EQUAL) { if (filterValue.equals(elementValue)) { return true; } } return false; }
/** * Matches an extension in a case insensitive way. * * @param patternMatcher the pattern to match * @param filters the filters * @param extension the extension to match * @return false if one of the filter is not matching the extension * @since 7.0M2 */ public static boolean matches(Pattern patternMatcher, Collection<Filter> filters, Extension extension) { if (matches(patternMatcher, extension.getId().getId(), extension.getDescription(), extension.getSummary(), extension.getName(), ExtensionIdConverter.toStringList(extension.getExtensionFeatures()))) { for (Filter filter : filters) { if (!matches(filter, extension)) { return false; } } return true; } return false; }