public static void addFetch(IMutableSearch search, String property) { if (property == null || "".equals(property)) return; // null properties do nothing, don't bother to add them. List<String> fetches = search.getFetches(); if (fetches == null) { fetches = new ArrayList<String>(); search.setFetches(fetches); } fetches.add(property); }
/** * Modify the search by adding the given fields after the current fields in * the search. */ public static void mergeFieldsAfter(IMutableSearch search, List<Field> fields) { List<Field> list = search.getFields(); if (list == null) { list = new ArrayList<Field>(); search.setFields(list); } list.addAll(fields); }
public static void addFilter(IMutableSearch search, Filter filter) { List<Filter> filters = search.getFilters(); if (filters == null) { filters = new ArrayList<Filter>(); search.setFilters(filters); } filters.add(filter); }
/** * Copy the contents of the source search object to the destination search * object, overriding any contents previously found in the destination. All * destination properties reference the same objects from the source * properties. */ public static IMutableSearch shallowCopy(ISearch source, IMutableSearch destination) { destination.setSearchClass(source.getSearchClass()); destination.setDistinct(source.isDistinct()); destination.setDisjunction(source.isDisjunction()); destination.setResultMode(source.getResultMode()); destination.setFirstResult(source.getFirstResult()); destination.setPage(source.getPage()); destination.setMaxResults(source.getMaxResults()); destination.setFetches(source.getFetches()); destination.setFields(source.getFields()); destination.setFilters(source.getFilters()); destination.setSorts(source.getSorts()); return destination; }
/** * Modify the search by adding the given filters using OR semantics */ public static void mergeFiltersOr(IMutableSearch search, List<Filter> filters) { List<Filter> list = search.getFilters(); if (list == null) { list = new ArrayList<Filter>(); search.setFilters(list); } if (list.size() == 0 || search.isDisjunction()) { search.setDisjunction(true); list.addAll(filters); } else { search.setFilters(new ArrayList<Filter>()); // add the previous filters with an AND Filter orFilter = Filter.and(); orFilter.setValue(list); addFilter(search, orFilter); // add the new filters with or search.setDisjunction(true); search.getFilters().addAll(filters); } }
/** * Copy the contents of the source search object to the destination search * object, overriding any contents previously found in the destination. All * collections are copied into new collections, but the items in those * collections are not duplicated; they still point to the same objects. */ public static <T extends IMutableSearch> T copy(ISearch source, T destination) { shallowCopy(source, destination); ArrayList<String> fetches = new ArrayList<String>(); fetches.addAll(source.getFetches()); destination.setFetches(fetches); ArrayList<Field> fields = new ArrayList<Field>(); fields.addAll(source.getFields()); destination.setFields(fields); ArrayList<Filter> filters = new ArrayList<Filter>(); filters.addAll(source.getFilters()); destination.setFilters(filters); ArrayList<Sort> sorts = new ArrayList<Sort>(); sorts.addAll(source.getSorts()); destination.setSorts(sorts); return destination; }
public static void clear(IMutableSearch search) { clearFilters(search); clearSorts(search); clearFields(search); clearPaging(search); clearFetches(search); search.setResultMode(RESULT_AUTO); search.setDisjunction(false); }
public static void clearFilters(IMutableSearch search) { if (search.getFilters() != null) search.getFilters().clear(); }
public static void removeFetch(IMutableSearch search, String property) { if (search.getFetches() != null) search.getFetches().remove(property); }
/** * Modify the search by adding the given filters using AND semantics */ public static void mergeFiltersAnd(IMutableSearch search, List<Filter> filters) { List<Filter> list = search.getFilters(); if (list == null) { list = new ArrayList<Filter>(); search.setFilters(list); } if (list.size() == 0 || !search.isDisjunction()) { search.setDisjunction(false); list.addAll(filters); } else { search.setFilters(new ArrayList<Filter>()); // add the previous filters with an OR Filter orFilter = Filter.or(); orFilter.setValue(list); addFilter(search, orFilter); // add the new filters with AND search.setDisjunction(false); search.getFilters().addAll(filters); } }
/** * Modify the search by adding the given sorts before the current sorts in * the search. */ public static void mergeSortsBefore(IMutableSearch search, List<Sort> sorts) { List<Sort> list = search.getSorts(); if (list == null) { list = new ArrayList<Sort>(); search.setSorts(list); } if (list.size() > 0) { // remove any sorts from the search that already sort on the same // property as one of the new sorts Iterator<Sort> itr = list.iterator(); while (itr.hasNext()) { String property = itr.next().getProperty(); if (property == null) { itr.remove(); } else { for (Sort sort : sorts) { if (property.equals(sort.getProperty())) { itr.remove(); break; } } } } } list.addAll(0, sorts); }
public static void removeFilter(IMutableSearch search, Filter filter) { List<Filter> filters = search.getFilters(); if (filters != null) filters.remove(filter); }
public static void clearFetches(IMutableSearch search) { if (search.getFetches() != null) search.getFetches().clear(); }
/** * Modify the search by adding the given fields before the current fields in * the search. */ public static void mergeFieldsBefore(IMutableSearch search, List<Field> fields) { List<Field> list = search.getFields(); if (list == null) { list = new ArrayList<Field>(); search.setFields(list); } list.addAll(0, fields); }
/** * Modify the search by adding the given sorts after the current sorts in * the search. */ public static void mergeSortsAfter(IMutableSearch search, List<Sort> sorts) { List<Sort> list = search.getSorts(); if (list == null) { list = new ArrayList<Sort>(); search.setSorts(list); } int origLen = list.size(); if (origLen > 0) { // don't add sorts that are already in the list for (Sort sort : sorts) { if (sort.getProperty() != null) { boolean found = false; for (int i = 0; i < origLen; i++) { if (sort.getProperty().equals(list.get(i).getProperty())) { found = true; break; } } if (!found) list.add(sort); } } } else { list.addAll(sorts); } }