/** * Set the list of {@link MetadataFilter}s that make up this chain. * * @param newFilters list of {@link MetadataFilter}s that make up this chain */ public void setFilters(@Nonnull @NonnullElements final List<MetadataFilter> newFilters) { Constraint.isNotNull(newFilters, "Filter collection cannot be null"); filters = new ArrayList<>(Collections2.filter(newFilters, Predicates.notNull())); }
/** * Return those {@link IdPAttributeValue}s which match this rule, or null if the matcher failed. * * @param attribute the attribute under question. * @param filterContext the filter context * @return The result of this rule. Null if we failed. */ @Nullable @NonnullElements @Unmodifiable public Set<IdPAttributeValue<?>> getMatchingValues( @Nonnull final IdPAttribute attribute, @Nonnull final AttributeFilterContext filterContext);
/** {@inheritDoc} */ @Nullable @NonnullElements @Unmodifiable @NotLive public Set<MetadataIndexKey> generateKeys(@Nonnull final EntityDescriptor descriptor) { Constraint.isNotNull(descriptor, "EntityDescriptor was null"); return descriptorStrategy.apply(descriptor); }
/** * Set the authentication flows to use. * * @param flows flow identifiers to use */ public void setAuthenticationFlows(@Nullable @NonnullElements final Collection<String> flows) { if (flows != null) { authenticationFlows = new HashSet<>(StringSupport.normalizeStringCollection(flows)); } else { authenticationFlows = Collections.emptySet(); } }
/** * Get a modifiable collection of timer name / stop object pairs for the supplied * start object ID. * * @param objectId the object ID input * * @return the collection of associated mappings */ @Nonnull @NonnullElements @Live public Collection<Pair<String,String>> getTimerMappings( @Nonnull @NotEmpty final String objectId) { return timerMap.get(objectId); }
/** * Set the confirmation methods to use. * * @param methods confirmation methods to use */ public void setMethods(@Nonnull @NonnullElements final Collection<String> methods) { ComponentSupport.ifInitializedThrowUnmodifiabledComponentException(this); Constraint.isNotEmpty(methods, "Confirmation method collection cannot be null or empty"); confirmationMethods = new ArrayList<>(Collections2.filter(methods, Predicates.notNull())); }
@Nullable private ProfileInterceptorFlowDescriptor attemptedFlow; @Nonnull @NonnullElements private final Map<String, ProfileInterceptorFlowDescriptor> availableFlows; @Nonnull @NonnullElements private final List<ProfileInterceptorResult> results;
/** {@inheritDoc} */ @Nullable @NonnullElements @Unmodifiable @NotLive public Set<MetadataIndexKey> generateKeys(@Nonnull final CriteriaSet criteriaSet) { Constraint.isNotNull(criteriaSet, "CriteriaSet was null"); return criteriaStrategy.apply(criteriaSet); }
/** * Set the ordered collection of outbound interceptor flows to enable. * * @param flows flow identifiers to enable */ public void setOutboundInterceptorFlows(@Nullable @NonnullElements final Collection<String> flows) { if (flows != null) { outboundFlows = new ArrayList<>(StringSupport.normalizeStringCollection(flows)); } else { outboundFlows = Collections.emptyList(); } }
/** * Get a live collection of values associated with a field. * * @param field field to retrieve * * @return the field's values */ @Nonnull @NonnullElements @Live public Collection<String> getFieldValues(@Nonnull @NotEmpty final String field) { return fieldMap.get(field); }
/** * Constructor. * * @param candidates the {@link Candidate} criteria to check for */ public EntityAttributesPredicate(@Nonnull @NonnullElements final Collection<Candidate> candidates) { Constraint.isNotNull(candidates, "Attribute collection cannot be null"); candidateSet = new ArrayList<>(Collections2.filter(candidates, Predicates.notNull())); trimTags = true; matchAll = false; }
@Nullable private String defaultView; @Nonnull @NonnullElements private Map<String,String> eventMap;
/** * Get an immutable collection of RP contexts associated with a label. * * @param label the label to search for * * @return corresponding RP contexts */ @Nonnull @NonnullElements @NotLive @Unmodifiable public Collection<RelyingPartyContext> getRelyingPartyContexts( @Nonnull @NotEmpty final String label) { return ImmutableList.copyOf(relyingPartyLabelMap.get( Constraint.isNotNull(StringSupport.trimOrNull(label), "Label cannot be null or empty"))); }
/** * Set the error messages to check for classifying a driver error as retryable, generally indicating * a lock violation or duplicate insert that signifies a broken database. * * @param errors retryable messages */ public void setRetryableErrors(@Nullable @NonnullElements final Collection<String> errors) { idStore.setRetryableErrors(errors); }
/** * Get a live collection of sessions associated with a service. * * @param id name of service to retrieve * * @return the sessions for the service */ @Nonnull @NonnullElements @Live public Collection<SPSession> getSessions(@Nonnull @NotEmpty final String id) { return sessionMap.get(id); }
/** * Set the address ranges to check against. * * @param ranges address ranges to check against * * @since 3.3.0 */ public void setRanges(@Nonnull @NonnullElements Collection<IPRange> ranges) { Constraint.isNotNull(ranges, "Address range collection cannot be null"); addressRanges = new ArrayList<>(Collections2.filter(ranges, Predicates.notNull())); }
@Nullable private Certificate certificate; @Nonnull @NonnullElements private Collection<Certificate> intermediates;
/** * Constructor. * * @param prefix prefix to attach to metric name before evaluating * @param map map of metric names to logging levels */ public LoggerDrivenMetricFilter(@Nonnull @NotEmpty @ParameterName(name="prefix") final String prefix, @Nullable @NonnullElements @ParameterName(name="map") final Map<String,Level> map) { loggerPrefix = Constraint.isNotNull(StringSupport.trimOrNull(prefix), "Prefix cannot be null or empty."); if (map == null || map.isEmpty()) { levelMap = Collections.emptyMap(); } else { levelMap = new HashMap(map.size()); for (final Map.Entry<String,Level> entry : map.entrySet()) { final String trimmed = StringSupport.trimOrNull(entry.getKey()); if (trimmed != null && entry.getValue() != null) { levelMap.put(trimmed, entry.getValue()); } } } }
/** * Set the ordered collection of inbound interceptor flows to enable. * * @param flows flow identifiers to enable */ public void setInboundInterceptorFlows(@Nullable @NonnullElements final Collection<String> flows) { if (flows != null) { inboundFlows = new ArrayList<>(StringSupport.normalizeStringCollection(flows)); } else { inboundFlows = Collections.emptyList(); } }
/** * Lookup the specified entityID from the index. The returned list will be a copy of what is stored in the backing * index, and is safe to be manipulated by callers. * * @param entityID the entityID to lookup * * @return list copy of indexed entityID's, may be empty, will never be null */ @Nonnull @NonnullElements protected List<EntityDescriptor> lookupIndexedEntityID( @Nonnull @NotEmpty final String entityID) { final List<EntityDescriptor> descriptors = getBackingStore().getIndexedDescriptors().get(entityID); if (descriptors != null) { return new ArrayList<>(descriptors); } else { return Collections.emptyList(); } }