Get Goals filtered by the criteria specified in the passed in filter.

@param filter Limit the items returned. If null, then all items returned.
@return Collection of items as specified in the filter.
551405
public Collection<Goal> goals(GoalFilter filter) {
        return get(Goal.class, (filter != null) ? filter : new GoalFilter());
    }
1072910
public Collection<FileInfo> getFileInfo(final Predicate<FileInfo> filter) {
        return files.values().stream()
                .filter(filter)
                .collect(Collectors.toList());
    }
1242485
public Collection<Effort> getEffortRecords(EffortFilter filter) {
        filter = (filter == null) ? new EffortFilter() : filter;

        filter.workitem.clear();
        filter.workitem.add(this);
        return getInstance().get().effortRecords(filter);
    }
558454
public static policyexpression[] get_filtered(nitro_service service, String filter) throws Exception{
		policyexpression obj = new policyexpression();
		options option = new options();
		option.set_filter(filter);
		policyexpression[] response = (policyexpression[]) obj.getfiltered(service, option);
		return response;
	}
357870
public static fis[] get_filtered(nitro_service service, String filter) throws Exception{
		fis obj = new fis();
		options option = new options();
		option.set_filter(filter);
		fis[] response = (fis[]) obj.getfiltered(service, option);
		return response;
	}
248352
@Override
    public Iterable<T> findAll(EntityFilter<T> filter) {
        List<T> results = new ArrayList<>();
        for (T object : findAll()) {
            if (filter.accept(object)) {
                results.add(object);
            }
        }
        return results;
    }
1136556
public Collection<Message> messages(MessageFilter filter) {
        return get(Message.class, (filter != null) ? filter : new MessageFilter());
    }
78218
public static <T> Collection<T> filter(Collection<T> data, Filter<T> filter) {
        if (!Utils.isEmpty(data)) {
            Iterator<T> iterator = data.iterator();
            while (iterator.hasNext()) {
                T item = iterator.next();
                if (!filter.accept(item)) {
                    iterator.remove();
                }
            }
        }
        return data;
    }
576187
public Collection<SecondaryWorkitem> secondaryWorkitems(
            SecondaryWorkitemFilter filter) {
        return get(SecondaryWorkitem.class, (filter != null) ? filter : new SecondaryWorkitemFilter());
    }
314120
public static appflowcollector[] get_filtered(nitro_service service, String filter) throws Exception{
		appflowcollector obj = new appflowcollector();
		options option = new options();
		option.set_filter(filter);
		appflowcollector[] response = (appflowcollector[]) obj.getfiltered(service, option);
		return response;
	}
62345
public Iterator<?> getElements(Filter filter, int offset, int maxResultSize) throws LayerException {
		if (null == filter) {
			filter = Filter.INCLUDE;
		}
		List<Object> filteredList = new ArrayList<Object>();
		try {
			synchronized (featuresById) {
				for (Object feature : featuresById.values()) {
					if (filter.evaluate(feature)) {
						filteredList.add(feature);
					}
				}
			}
		} catch (Exception e) { // NOSONAR
			throw new LayerException(e, ExceptionCode.FILTER_EVALUATION_PROBLEM, filter, getId());
		}
		// Sorting of elements.
		if (comparator != null) {
			Collections.sort(filteredList, comparator);
		}
		if (maxResultSize > 0) {
			int fromIndex = Math.max(0, offset);
			int toIndex = Math.min(offset + maxResultSize, filteredList.size());
			toIndex = Math.max(fromIndex, toIndex);
			return filteredList.subList(fromIndex, toIndex).iterator();
		} else {
			return filteredList.iterator();
		}
	}
670590
public Collection<Retrospective> getRetrospectives(
            RetrospectiveFilter filter) {
        filter = (filter == null) ? new RetrospectiveFilter() : filter;

        filter.team.clear();
        filter.team.add(this);
        return getInstance().get().retrospectives(filter);
    }
375982
public RemoteFindIterable<DocumentT> find(final Bson filter) {
    return new RemoteFindIterableImpl<>(proxy.find(filter), dispatcher);
  }
1308111
protected List<CmsTreeItem> getFilteredCategories(String filter) {

        List<CmsTreeItem> result = new ArrayList<CmsTreeItem>();
        if (CmsStringUtil.isNotEmptyOrWhitespaceOnly(filter)) {
            result = new ArrayList<CmsTreeItem>();
            for (CmsTreeItem category : m_categories.values()) {
                if (((CmsDataValue)category.getMainWidget()).matchesFilter(filter, 0, 1)) {
                    result.add(category);
                }
            }
        } else {
            Iterator<CmsTreeItem> it = m_categories.values().iterator();
            while (it.hasNext()) {
                result.add(it.next());
            }

        }
        return result;
    }
834555
public static <T> List<T> filter(Collection<T> items, Predicate<T> predicate) {
        List<T> result = new ArrayList<>();

        if (!isEmpty(items)) {
            for (T item : items) {
                if (predicate.apply(item)) {
                    result.add(item);
                }
            }
        }

        return result;
    }
1234191
public Collection<Effort> effortRecords(EffortFilter filter) {
        return get(Effort.class, (filter != null) ? filter : new EffortFilter());
    }
1026973
public Iterator iterateObjects(org.kie.api.runtime.ObjectFilter filter) {
        return getObjectStore().iterateObjects(filter);
    }