@Override
public List<Tablet> meetCriteria(List<Tablet> tablets) {
HashSet<Tablet> tabletHash = new HashSet<>();
for (AbstractFilter filter : filters) {
tabletHash.addAll(filter.meetCriteria(tablets));
}
return new ArrayList<>(tabletHash);
}
/**
* Delete a filter from the model.
*
* @param filtername the name of the filter to delete
* @throws Exception when filter to remove is not found
*/
public void deleteFilter(final String filtername) throws Exception {
boolean isfound = false;
for (int i = 0; i < filters.size(); i++) {
AbstractFilter c = filters.get(i);
if (c.getName().compareTo(filtername) == 0) {
isfound = true;
filters.remove(i);
break;
}
}
if (!isfound) {
throw new Exception("Filter Model : filter to remove not found");
}
}
@Override
public void afterPropertiesSet() throws ServletException {
super.afterPropertiesSet();
Assert.notNull(cacheOperationSource, "cacheOperationSource is required");
Assert.notNull(expressionEvaluator, "expressionEvaluator is required");
Assert.notNull(keyGenerator, "keyGenerator is required");
}
/**
* Flushes any buffered but not yet written characters. Subclasses which override this method
* should call this method <em>before</em> flushing any of their own buffers.
*/
public void flush() throws IOException {
super.flush();
if (state == S_text && currentCharacters.length() > 0) {
handleText(currentCharacters.toString());
currentCharacters = new StringBuffer();
}
}
@Override
public void init(FilterConfig filterConfig) throws ServletException {
super.init(filterConfig);
/* Save the configuration so that we can use it to re-initialize the wicket filter at request time, as
* we may need to do it again if changes are hot deployed. Also, look up the delegate now, as the presence
* of the delegate component implies the presence of the wicket classes themselves.
*/
if (delegate == null) {
delegate =
(javax.servlet.Filter)
Component.getInstance(
"org.jboss.seam.wicket.web.wicketFilterInstantiator", ScopeType.STATELESS);
savedConfig = filterConfig;
}
}
/**
* Closes the parser. Currently, this simply does a <code>flush()</code>, followed by some minimal
* consistency checks.
*/
public void close() throws IOException {
flush();
if (state != S_text || level > 0) {
warning("Truncated RTF file.");
/* TODO: any sane way to handle termination in a non-S_text state? */
/* probably not */
/* this will cause subclasses to behave more reasonably
some of the time */
while (level > 0) {
endgroup();
level--;
}
}
super.close();
}
public static Value filter_input(
Env env, int type, StringValue name, @Optional Value filterIdV, @Optional Value flagV) {
ArrayValue array;
switch (type) {
case INPUT_POST:
array = env.getInputPostArray();
break;
case INPUT_GET:
array = env.getInputGetArray();
break;
case INPUT_COOKIE:
array = env.getInputCookieArray();
break;
case INPUT_ENV:
array = env.getInputEnvArray();
break;
default:
return env.warning(L.l("filter input type is unknown: {0}", type));
}
Filter filter = getFilter(env, filterIdV);
Value value = array.get(name);
if (value == UnsetValue.UNSET) {
int flags = AbstractFilter.getFlags(env, flagV);
if ((flags & FILTER_NULL_ON_FAILURE) > 0) {
return BooleanValue.FALSE;
} else {
return NullValue.NULL;
}
}
return filter.filter(env, value, flagV);
}
