/** 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; }
/** doesn't return a new entry. only changes key and value */ protected Entry filter(String fieldId, Entry entry) { if (entry != null && hasntSeen(entry)) { addSeen(entry); enter(entry); Object key = filter(fieldId, entry.key); Object value = filter(fieldId, entry.value); exit(entry); entry.key = key; entry.value = value; } return entry; }
public boolean exit(Object o) { pop(o); return true; }
public Filterable filter(String fieldId, Filterable f) { if (f != null && hasntSeen(f)) { beforeFilter(fieldId, f); doFilter(fieldId, f); afterFilter(fieldId, f); } return f;// null; }
@Override public Filterable filter(String fieldId, Filterable f) { entry(fieldId, f); return super.filter(fieldId, f); }
/** * 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; }
@Override protected void doFilter(String fieldId, Filterable f) { if (!(f instanceof Details)) { super.doFilter(fieldId, f); } }
public boolean enter(Object o) { push(o); return true; }
protected void afterFilter(String fieldId, Object o) { exit(o); }
protected void doFilter(String fieldId, Collection c) { List copy = new ArrayList(); for (Iterator iter = c.iterator(); iter.hasNext();) { Object item = iter.next(); Object result = filter(fieldId, item); copy.add(result); } try { c.clear(); c.addAll(copy); } catch (UnsupportedOperationException uoe) { // This should only happen for the primitive // array types like Namespace.keywords. // Do nothing. } }
/** * 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; }
@Override protected void doFilter(String fieldId, Filterable f) { if (Hibernate.isInitialized(f)) { super.doFilter(fieldId, f); } }
@Override public Object filter(String fieldId, Object o) { entry(fieldId, o); return super.filter(fieldId, o); }
@Override protected void doFilter(String fieldId, Collection c) { if (Hibernate.isInitialized(c)) { super.doFilter(fieldId, c); } }
@Override public Map filter(String fieldId, Map m) { if (null == m || !Hibernate.isInitialized(m)) { return null; } Map retVal = super.filter(fieldId, m); // ticket:61 : preventing Hibernate collection types from escaping. if (retVal instanceof AbstractPersistentCollection) { retVal = new HashMap(retVal); } // end ticket:61 return retVal; }
@Override public Collection filter(String fieldId, Collection c) { // is a proxy. null it. will be refilled by // MergeEventListener on re-entry. if (null == c || !Hibernate.isInitialized(c)) { return null; } Collection retVal = super.filter(fieldId, c); // ticket:61 : preventing Hibernate collection types from escaping. if (retVal instanceof AbstractPersistentCollection) { if (retVal instanceof Set) { retVal = new HashSet(retVal); } else if (retVal instanceof List) { retVal = new ArrayList(retVal); } } // end ticket:61 return retVal; }
/** * Prevents CountPerOwner from being loaded unnecessarily. * @see <a href="https://trac.openmicroscopy.org/ome/ticket/3978">Trac ticket #3978</a> */ @Override public Map filter(String fieldId, Map m) { if (fieldId != null && fieldId.endsWith("CountPerOwner")) { beforeFilter(fieldId, m); afterFilter(fieldId, m); return m; } return super.filter(fieldId, m); }
@Override public Map filter(String fieldId, Map source) { Map o = super.filter(fieldId, source); Map target = findMap(o); fillMap(source, target); return o; }
@Override public Collection filter(String fieldId, Collection source) { Collection o = super.filter(fieldId, source); Collection target = findCollection(o); fillCollection(source, target); return o; }