Accept fields with non null value.

@return The filter.
772302
public static Filter<InstanceField> syntheticField() {
        return new Filter<InstanceField>() {
            public boolean isOut(InstanceField instanceField) {
                return instanceField.isSynthetic();
            }
        };
    }
392700
@Override
    public boolean filter(Object data) {
        logger.entering(data);
        String[] keyValues = filterKeyValues.split(",");
        String tempKey = null;
        Field field;

        try {
            field = data.getClass().getDeclaredField(filterKeyName);
            field.setAccessible(true);
            for (String keyValue : keyValues) {
                tempKey = keyValue;
                if (field.get(data) != null && field.get(data).toString().trim().equals(keyValue)) {
                    logger.exiting(true);
                    return true;
                }
            }
        } catch (NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException e) {
            throw new DataProviderException("Row with key '" + tempKey + "' is not found for given filter key '"
                    + filterKeyName + "'", e);
        }
        logger.exiting(false);
        return false;
    }
333134
public static TreeModelFilter acceptingAll()
    {
        return new TreeModelFilter()
        {
            @Override
            public boolean acceptNode(TreeModel treeModel, TreeNode node)
            {
                return true;
            }
            
            @Override
            public String toString()
            {
                return "TreeModelFilter[acceptingAll]";
            }
        };
    }
40275
private boolean acceptValue(int row, Map<Integer, Object> filter) {
		boolean accept = true;
		Set<Integer> keys = filter.keySet();
		for (int index : keys) {
			if (!filter.get(index).equals(dataSource.getValueAt(row, fields.get(index)))) {
				// System.out.println(" + " + filter.get(j));
				// System.out.println(" - " + dataSource.getValueAt(i,
				// fields.get(j)));
				return false;
			}
		}

		return accept;
	}
747408
public static Query notIn(String field, Collection<?> values) {
        return new Query().notIn(field, values);
    }
1062390
private Filter createValueMatchFilter(
      FilterAdapterContext context, SingleColumnValueFilter filter) throws IOException {
    ValueFilter valueFilter = new ValueFilter(filter.getOperator(), filter.getComparator());
    return delegateAdapter.toFilter(context, valueFilter);
  }
1360860
private Map<Integer, Object> getFilter(List<PivotField> fields, List<Object> values) {
//		long start = System.currentTimeMillis();
		Map<Integer, Object> filter = new HashMap<Integer, Object>();
		for (int i = 0; i < values.size(); i++) {
			int fieldIndex = fields.get(i).getIndex();
			// System.out.println(fieldIndex);
			filter.put(fieldIndex, values.get(i));
		}
//		long stop = System.currentTimeMillis();
//		System.out.println("getFilter in " + (stop - start));
	
		return filter;
	}
944296
public <E extends Exception> boolean noneMatch(Try.LongPredicate<E> filter) throws E {
        return noneMatch(0, size(), filter);
    }
1292764
public Search validate(Schema schema) {
        filter.forEach(condition -> condition.query(schema));
        query.forEach(condition -> condition.query(schema));
        sort.forEach(field -> field.sortField(schema));
        return this;
    }
1104268
@Override
    public StringBuilder getFilterClause() {
        StringBuilder builder = new StringBuilder();
        builder.append(columnName);
        builder.append(" LIKE ");
        builder.append(':').append(name);
        if (condition != null) {
            builder.append(" AND ");
            builder.append(condition);
        }
        return builder;
    }
1220010
@NotNull
    public OptionalLong filter(@NotNull LongPredicate predicate) {
        if (!isPresent()) return this;
        return predicate.test(value) ? this : OptionalLong.empty();
    }
1128204
public ServerFilter where(Predicate<ServerMetadata> filter) {
        checkNotNull(filter, "Filter must be not a null");

        predicate = predicate.and(filter);

        return this;
    }
144805
public static Set<Field> getDeclaredFields(Class<?> clazz, FieldFilter filter) {
        Set<Field> fields = new HashSet<Field>();
        Field[] allFields = clazz.getDeclaredFields();
        for(Field field : allFields) {
            if(filter.passFilter(field)) {
                fields.add(field);
            }
        }
        return fields;
    }
1020512
public FilterValues<S> with(char value) {
        PropertyFilterList<S> current = currentProperty();
        Object obj;
        try {
            obj = current.getPropertyFilter().adaptValue(value);
        } catch (IllegalArgumentException e) {
            throw mismatch(e);
        }
        return with(current, obj);
    }
279304
public Filters addField(String field, String value) {
        initialFields();
        fields.add(new FieldFilter(field, value));
        return this;
    }
919203
protected Filter getFilter() {
        switch (mAutoCompleteMode){
            case AUTOCOMPLETE_MODE_SINGLE:
                return ((InternalAutoCompleteTextView)mInputView).superGetFilter();
            case AUTOCOMPLETE_MODE_MULTI:
                return ((InternalMultiAutoCompleteTextView)mInputView).superGetFilter();
            default:
                return null;
        }
    }
1329528
public static Set<Field> getFields(Class<?> target, FieldFilter filter) {
        Class<?> clazz = target;
        Set<Field> fields = getDeclaredFields(clazz, filter);
        while((clazz = clazz.getSuperclass()) != null) {    
            fields.addAll(getDeclaredFields(clazz, filter));
        }
        return fields;
    }