Gets JSON data from a resource by applying the given filter.

@param dataFilter
an implementation class of {@link DataProviderFilter}
964572
@Override
    public Iterator<Object[]> getDataByFilter(DataProviderFilter dataFilter) {
        Preconditions.checkArgument(resource != null, "File resource cannot be null");
        logger.entering(dataFilter);
        Class<?> arrayType;
        JsonReader reader = null;
        try {
            reader = new JsonReader(getReader(resource));
            arrayType = Array.newInstance(resource.getCls(), 0).getClass();
            Gson myJson = new Gson();
            Object[] mappedData = myJson.fromJson(reader, arrayType);
            return prepareDataAsObjectArrayList(mappedData, dataFilter).iterator();
        } catch (Exception e) {
            throw new DataProviderException(e.getMessage(), e);
        } finally {
            IOUtils.closeQuietly(reader);
        }
    }
281892
public static nshttpprofile[] get_filtered(nitro_service service, String filter) throws Exception{
		nshttpprofile obj = new nshttpprofile();
		options option = new options();
		option.set_filter(filter);
		nshttpprofile[] response = (nshttpprofile[]) obj.getfiltered(service, option);
		return response;
	}
568804
public void filterUpdate(DataSetFilter filter) {
        if (displayerSettings.isFilterEnabled()) {

            DataSetFilter oldFilter = currentFilter;
            this.currentFilter = filter;

            // Notify to those interested parties the selection event.
            if (displayerSettings.isFilterNotificationEnabled()) {
                for (DisplayerListener listener : listenerList) {
                    listener.onFilterUpdate(this, oldFilter, filter);
                }
            }
            // Drill-down support
            if (displayerSettings.isFilterSelfApplyEnabled()) {
                dataSetHandler.unfilter(oldFilter);
                dataSetHandler.filter(filter);
                redraw();
            }
        }
    }
1261373
public void filterApply(DataSetFilter filter) {
        if (displayerSettings.isFilterEnabled()) {

            this.currentFilter = filter;

            // Notify to those interested parties the selection event.
            if (displayerSettings.isFilterNotificationEnabled()) {
                for (DisplayerListener listener : listenerList) {
                    listener.onFilterEnabled(this, filter);
                }
            }
            // Drill-down support
            if (displayerSettings.isFilterSelfApplyEnabled()) {
                dataSetHandler.filter(filter);
                redraw();
            }
        }
    }
21962
@Override
    public BlobContract withFilter(ServiceFilter filter) {
        ClientFilter[] currentFilters = getFilters();
        ClientFilter[] newFilters = Arrays.copyOf(currentFilters,
                currentFilters.length + 1);
        newFilters[currentFilters.length] = new ClientFilterAdapter(filter);
        return new MediaBlobRestProxy(getChannel(), newFilters,
                getAccountName(), getUrl(), this.tokenFilter, getDateMapper());
    }
324773
public void initFilter(FunDapterFilter<T> filter) {

        if (filter == null)
            throw new IllegalArgumentException("Cannot pass a null filter to FunDapter");

        this.funDapterFilter = filter;

        mFilter = new Filter() {

            @Override
            protected void publishResults(CharSequence constraint, FilterResults results) {

                @SuppressWarnings("unchecked") List<T> list = (List<T>) results.values;

                if (results.count == 0) {
                    resetData();
                } else {
                    mDataItems = list;
                }

                notifyDataSetChanged();
            }

            @Override
            protected FilterResults performFiltering(CharSequence constraint) {

                FilterResults results = new FilterResults();
                if (constraint == null || constraint.length() == 0) {

                    // No constraint - no point in filtering.
                    results.values = mOrigDataItems;
                    results.count = mOrigDataItems.size();
                } else {
                    // Perform the filtering operation

                    List<T> filter =
                            funDapterFilter.filter(constraint.toString(), mOrigDataItems);

                    results.count = filter.size();
                    results.values = filter;

                }

                return results;
            }
        };
    }
250054
public static service[] get_filtered(nitro_service service, String filter) throws Exception{
		service obj = new service();
		options option = new options();
		option.set_filter(filter);
		service[] response = (service[]) obj.getfiltered(service, option);
		return response;
	}
174723
public static route6[] get_filtered(nitro_service service, String filter) throws Exception{
		route6 obj = new route6();
		options option = new options();
		option.set_filter(filter);
		route6[] response = (route6[]) obj.getfiltered(service, option);
		return response;
	}
70167
public static dnskey[] get_filtered(nitro_service service, String filter) throws Exception{
		dnskey obj = new dnskey();
		options option = new options();
		option.set_filter(filter);
		dnskey[] response = (dnskey[]) obj.getfiltered(service, option);
		return response;
	}
216468
@Bind(aggregate = true, optional = true)
    public void bindFilter(Filter filter) {
        filters.add(filter);
    }
282582
public static route[] get_filtered(nitro_service service, String filter) throws Exception{
		route obj = new route();
		options option = new options();
		option.set_filter(filter);
		route[] response = (route[]) obj.getfiltered(service, option);
		return response;
	}
621951
public void applyFilter(int filter) {
        Filters.checkFilterArgument(filter);
        mDisplayRenderer.changeFilterMode(filter);
        synchronized (mReadyForFrameFence) {
            mNewFilter = filter;
        }
    }
729127
@Override
    public T filter(Filter<ArchivePath> filter) {
        return this.shallowCopy(filter).as(getActualClass());
    }
1169539
public static cacheselector[] get_filtered(nitro_service service, String filter) throws Exception{
		cacheselector obj = new cacheselector();
		options option = new options();
		option.set_filter(filter);
		cacheselector[] response = (cacheselector[]) obj.getfiltered(service, option);
		return response;
	}
542752
public static dnssuffix[] get_filtered(nitro_service service, String filter) throws Exception{
		dnssuffix obj = new dnssuffix();
		options option = new options();
		option.set_filter(filter);
		dnssuffix[] response = (dnssuffix[]) obj.getfiltered(service, option);
		return response;
	}
1036545
@Override
    public void setFilter(Service.Filter filter) {
        _filter = _filter == null ? filter : new CompoundServiceFilter(filter, _filter);
    }
54455
protected T getTypedFilter(Filter filter) {
    if (isFilterAProperSublcass(filter)) {
      return unchecked(filter);
    }
    throw new IllegalStateException(
        String.format(
            "FilterAdapter %s cannot operate on a filter of type %s",
            getClass().getCanonicalName(),
            filter.getClass().getCanonicalName()));
  }