@Override public StreamsActivityProvider getModule() { initModules(); // we need to call this here in case enabled() wasn't called, as is in the case in Bamboo 2.7 return provider; }
/** * If true, the values of this filter option should be shown as separate pseudo-providers * in the filter UI. * * @return True if the values of the filter option should be shown as provider aliases */ public boolean isProviderAlias() { return streamsFilterOption.isProviderAlias(); }
/** * The filter option i18n key * * @return The filter option i18n key */ public String getI18nKey() { return streamsFilterOption.getI18nKey(); }
StreamsFilterOptionImpl(StreamsFilterOption.Builder builder) { this.key = builder.getKey(); this.displayName = builder.getDisplayName(); this.helpTextI18nKey = builder.getHelpTextI18nKey(); this.i18nKey = builder.getI18nKey(); this.type = builder.getType(); this.unique = builder.isUnique(); this.providerAlias = builder.isProviderAlias(); this.values = builder.getValues(); }
/** * Creates a {@code Predicate} from the {@link CONTAINS} and {@link DOES_NOT_CONTAIN} operators in the list of filters. The returned * {@code Predicate} uses the {@link Function}s returned by {@link isContaining} and {@link isNotContaining} to construct the sub * {@code Predicate}s for each {@code Operator}, and then {@link and}s them all together. * * @param filters filters to create a predicate for * @return {@code Predicate} from the {@code CONTAINS} and {@code DOES_NOT_CONTAIN} filters */ public static Predicate<String> containsAndDoesNotContain(Iterable<Pair<Operator, Iterable<String>>> filters) { return containsAndDoesNotContain(filters, isContaining(), isNotContaining()); }
public Void apply(T instance) { evictor.apply(instance); return null; } });
public Predicate<String> apply(final Iterable<String> xs) { return new CaseInsensitive(xs); } }
/** * {@code Predicate} for removing any {@code StreamsEntry}s that match notted "filterUser" filters. * * @param request the {@code ActivityRequest} containing the filters * @return the {@code Predicate} */ public static Predicate<Iterable<String>> notInUsers(ActivityRequest request) { return new NotInUsers(request); }
/** * {@code Predicate} for filtering involving a {@code StreamEntry}'s authors. * * @param authorPredicate the author predicate to filter on * @return the {@code Predicate} */ public static Predicate<StreamsEntry> entryAuthors(Predicate<Iterable<String>> authorPredicate) { return new EntryAuthors(authorPredicate); }
/** * The filter option key * * @return The filter option key */ public String getKey() { return streamsFilterOption.getKey(); }
/** * The filter option display name * * @return The filter option display name */ public String getDisplayName() { return streamsFilterOption.getDisplayName(); }
/** * Whether the filter option accepts multiple values or not * * @return Whether the filter option accepts multiple values or not */ public boolean isUnique() { return streamsFilterOption.isUnique(); }
/** * @return a {@code Function} which takes a list of {@code String}s and returns a {@code Predicate} which determines * if a {@code String} matches the {@code Predicate} created from {@code f} in a case insensitive way. An example * of this is in practice is allowing a case insensitive check if a {@code String} is in a list {@code String}s, * {@code caseInsensitive(isIn())}. */ public static Function<Iterable<String>, Predicate<String>> caseInsensitive(final Function<Iterable<String>, Predicate<String>> f) { return new AsCaseInsensitive(f); }
/** * The filter option type * * @return The filter option type */ public StreamsFilterType getFilterType() { return streamsFilterOption.getFilterType(); }
public Boolean apply(T t, Boolean allSuccess) { return add(t) && allSuccess; } });
public StreamsCommentHandler getCommentHandler() { initModules(); return commentHandler; }
public StreamsFilterOptionProvider getFilterOptionProvider() { initModules(); return filterOptionProvider; }
public StreamsKeyProvider getKeyProvider() { initModules(); return keyProvider; }
public StreamsValidator getValidator() { initModules(); return validator; }