/** * filters both the key and value sets of the map. Adds itself to the * context. Somewhat dangerous. */ public Map filter(String fieldId, Map m) { if (m != null && hasntSeen(m)) { beforeFilter(fieldId, m); Map add = new HashMap(); for (Iterator iter = m.entrySet().iterator(); iter.hasNext();) { Map.Entry _entry = (Map.Entry) iter.next(); Entry entry = new Entry(_entry.getKey(), _entry.getValue()); Entry result = filter(fieldId, entry); if (null == result) { iter.remove(); } else if (result.key != entry.key || result.value != entry.value) { iter.remove(); add.put(result.key, result.value); } } m.putAll(add); afterFilter(fieldId, m); } return m; }
public Filterable filter(String fieldId, Filterable f) { if (f != null && hasntSeen(f)) { beforeFilter(fieldId, f); doFilter(fieldId, f); afterFilter(fieldId, f); } return f;// null; }
/** * iterates over the contents of the collection and filters each. Adds * itself to the context. This is somewhat dangerous. */ public Collection filter(String fieldId, Collection c) { if (c != null && hasntSeen(c)) { beforeFilter(fieldId, c); doFilter(fieldId, c); afterFilter(fieldId, c); } return c; }
/** used when type is unknown. this is possibly omittable with generics */ public Object filter(String fieldId, Object o) { Object result; if (o instanceof Enum) { result = o; } else if (o instanceof ome.model.internal.Primitive) { result = o; } else if (o instanceof Filterable) { result = filter(fieldId, (Filterable) o); } else if (o instanceof Collection) { result = filter(fieldId, (Collection) o); } else if (o instanceof Map) { result = filter(fieldId, (Map) o); } else { beforeFilter(fieldId, o); doFilter(fieldId, o); afterFilter(fieldId, o); result = o; } return result; }