Retrieve the bounds of the specified features.

@param filter filter
@return the bounds of the specified features
@throws LayerException cannot read features
495570
public Envelope getBounds(Filter filter) throws LayerException {
		try {
			FeatureCollection<SimpleFeatureType, SimpleFeature> fc = getFeatureSource().getFeatures(filter);
			return fc.getBounds();
		} catch (IOException ioe) {
			throw new LayerException(ioe, ExceptionCode.FEATURE_MODEL_PROBLEM);
		}
	}
426198
@Override
    public Set<Class<?>> getDeclaredInterfaces(ClassFilter filter) {
       return ClassUtils.getDeclaredInterfaces(target, filter);
    }
1290326
public static transformprofile[] get_filtered(nitro_service service, String filter) throws Exception{
		transformprofile obj = new transformprofile();
		options option = new options();
		option.set_filter(filter);
		transformprofile[] response = (transformprofile[]) obj.getfiltered(service, option);
		return response;
	}
683506
@Override
    public  Set<Method> getDeclaredMethods(MethodFilter methodFilter) {
        return MethodUtils.getDeclaredMethods(target, methodFilter);
    }
1042729
public static JCGLFramebufferBlitFilter framebufferBlitFilterFromGL(
    final int filter)
  {
    switch (filter) {
      case GL11.GL_LINEAR: {
        return JCGLFramebufferBlitFilter.FRAMEBUFFER_BLIT_FILTER_LINEAR;
      }
      case GL11.GL_NEAREST: {
        return JCGLFramebufferBlitFilter.FRAMEBUFFER_BLIT_FILTER_NEAREST;
      }
      default:
        throw new UnreachableCodeException();
    }
  }
811113
public T filter(@NonNull SerializablePredicate<? super HString> filter) {
      this.filter = filter;
      return Cast.as(this);
   }
1072910
public Collection<FileInfo> getFileInfo(final Predicate<FileInfo> filter) {
        return files.values().stream()
                .filter(filter)
                .collect(Collectors.toList());
    }
1369422
public void setFilter(Filter filter)
    {
        if (this.filter == null)
        {
            this.filter = new FilterList();
        }
        if (filter != null)
        {
            this.filter.addFilter(filter);
        }
    }
212175
public Query<S> query(String filter) throws FetchException {
        synchronized (mStringToQuery) {
            Query<S> query = mStringToQuery.get(filter);
            if (query == null) {
                if (filter == null) {
                    throw new IllegalArgumentException("Query filter must not be null");
                }
                query = query(Filter.filterFor(mType, filter), null);
                mStringToQuery.put(filter, query);
            }
            return query;
        }
    }
943894
public static filteraction[] get_filtered(nitro_service service, String filter) throws Exception{
		filteraction obj = new filteraction();
		options option = new options();
		option.set_filter(filter);
		filteraction[] response = (filteraction[]) obj.getfiltered(service, option);
		return response;
	}
1314409
void setFilter(Filter filter)
    {
        this.filter = Optional.ofNullable(filter).orElse(FilterNone.INSTANCE);
        transform = getTransform();
    }
999983
public QueryScopeInfo getQueryServiceMetricInfo(CharacterFilter filter) {
		if (queryServiceScopeInfo == null) {
			queryServiceScopeInfo = createQueryServiceMetricInfo(filter);
		}
		return queryServiceScopeInfo;
	}
856754
@Override
    public Set<Field> getFields(FieldFilter filter) {
        return FieldUtils.getFields(target, filter);
    }
1305306
public static br[] get_filtered(nitro_service service, String filter) throws Exception
	{
		br obj = new br();
		options option = new options();
		option.set_filter(filter);
		br[] response = (br[]) obj.getfiltered(service, option);
		return response;
	}
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;
    }
421029
public List<ZuulFilter> getFiltersByType(FilterType filterType) {

        List<ZuulFilter> list = hashFiltersByType.get(filterType);
        if (list != null) return list;

        list = new ArrayList<ZuulFilter>();

        Collection<ZuulFilter> filters = filterRegistry.getAllFilters();
        for (Iterator<ZuulFilter> iterator = filters.iterator(); iterator.hasNext(); ) {
            ZuulFilter filter = iterator.next();
            if (filter.filterType().equals(filterType)) {
                list.add(filter);
            }
        }

        // Sort by filterOrder.
        Collections.sort(list, new Comparator<ZuulFilter>() {
            @Override
            public int compare(ZuulFilter o1, ZuulFilter o2) {
                return o1.filterOrder() - o2.filterOrder();
            }
        });

        hashFiltersByType.putIfAbsent(filterType, list);
        return list;
    }
497520
public void findClosestEdge(GHIntHashSet edgeIds, double lat, double lon, EdgeFilter filter) {
        QueryResult qr = locationIndex.findClosest(lat, lon, filter);
        if (qr.isValid())
            edgeIds.add(qr.getClosestEdge().getEdge());
    }