Get a PathFilter instance of the filter set for the input paths.

@return the PathFilter instance set for the job, NULL if none has been set.
176700
public static PathFilter getInputPathFilter(JobConf conf) {
    Class<? extends PathFilter> filterClass = conf.getClass(
	"mapred.input.pathFilter.class", null, PathFilter.class);
    return (filterClass != null) ?
        ReflectionUtils.newInstance(filterClass, conf) : null;
  }
591587
public static List<Path> getSubDirectoryPathList(Path startDirectoryPath,
			Predicate<Path> filter) {
		return getSubPathList(startDirectoryPath, Integer.MAX_VALUE,
				DirectoryAndNotSymbolicLinkFilter.and(filter));
	}
1215499
public static vpath[] get_filtered(nitro_service service, String filter) throws Exception{
		vpath obj = new vpath();
		options option = new options();
		option.set_filter(filter);
		vpath[] response = (vpath[]) obj.getfiltered(service, option);
		return response;
	}
1335655
private SearchFilter getSearchFilter(HttpServletRequest httpServletRequest) {
        SearchFilter ret = new SearchFilter();
        Set<String> keySet = httpServletRequest.getParameterMap().keySet();
        for (String key : keySet) {
            ret.setParam(String.valueOf(key), String.valueOf(httpServletRequest.getParameter(key)));
        }

        return ret;
    }
766813
public Filter toFilter() {
        Filter[] result = new Filter[filters.size()];
        for (int i = 0; i < result.length; i++) {
            result[i] = filters.get(i).createFilter();
        }
        return chain(result);
    }
1204391
protected FilenameFilter getFileFilter() {
		// accepts all files in default implementation
		return new FilenameFilter() {
			@Override
			public boolean accept(File dir, String name) {
				return true;
			}
		};

	}
1159234
@Nullable
    public static Filter getFilterProperty(@Nonnull LogManager manager, @Nullable String name, @Nullable Filter defaultValue) {
        if (name == null) {
            return defaultValue;
        }
        String val = manager.getProperty(name);
        try {
            if (val != null) {
                Class clz = ClassLoader.getSystemClassLoader().loadClass(val);
                return (Filter) clz.newInstance();
            }
        } catch (Exception ex) {
            // We got one of a variety of exceptions in creating the
            // class or creating an instance.
            // Drop through.
        }
        // We got an exception.  Return the defaultValue.
        return defaultValue;
    }
96723
public function pathFactory()
    {
        if (null === $this->pathFactory) {
            $this->pathFactory = $this->createDefaultPathFactory();
        }

        return $this->pathFactory;
    }
939060
public CmsRelationFilter filterStrong() {

        CmsRelationFilter filter = (CmsRelationFilter)clone();
        if (filter.m_types.isEmpty()) {
            filter.m_types.addAll(CmsRelationType.getAllStrong());
        } else {
            filter.m_types = new HashSet<CmsRelationType>(CmsRelationType.filterStrong(filter.m_types));
        }
        return filter;
    }
451128
public String getRawPath() {
    List<String> pathParts = this.pathParts;
    if (pathParts == null) {
      return null;
    }
    StringBuilder buf = new StringBuilder();
    appendRawPathFromParts(buf);
    return buf.toString();
  }
1006091
public String getPath()
    {
        final StringBuilder path = new StringBuilder();
        if (getPrevious() != null) {
            path.append(getPrevious().getPath());
        }
        return path.toString();
    }
1058709
public Collection<Workitem> workitems(WorkitemFilter filter) {
        return get(Workitem.class, (filter != null) ? filter : new WorkitemFilter());
    }
780849
public List<String> paths(Node dir, Filter filter) throws IOException {
    	List<String> result;

    	result = new ArrayList<>();
    	paths(dir, filter, result);
    	return result;
    }
904074
private static Filter<InstanceField> nullField() {
        return new Filter<InstanceField>() {
            public boolean isOut(InstanceField instanceField) {
                return instanceField.isNull();
            }
        };
    }
170122
public static Optional<String> getFilePathExtensionAsOpt(Path path) {
		return JMOptional
				.getNullableAndFilteredOptional(path, RegularFileFilter)
				.map(JMPath::getLastName).map(JMString::getExtension)
				.filter(getIsEmpty().negate());
	}
1032745
public PathImpl getBestPath()
  {
    /*
    if (_bestPath != null)
      return _bestPath;
      */

    ArrayList<PathImpl> pathList = getPathList();
    for (int i = 0; i < pathList.size(); i++) {
      PathImpl path = pathList.get(i);

      if (path.exists()) {
        return path;
      }
    }

    if (pathList.size() > 0) {
      return pathList.get(0);
    }

    return new NotFoundPath(getSchemeMap(), _userPath);
  }
297825
@NotNull
    public FileFilter getFileFilter() {
        if (fileFilter == null) {
            final List<IOFileFilter> filters = new ArrayList<>();
            final Parsers parsers = config.getParsers();
            if (parsers != null) {
                final List<ParserConfig> parserConfigs = parsers.getList();
                if (parserConfigs != null) {
                    for (final ParserConfig pc : parserConfigs) {
                        final Parser<Object> pars = pc.getParser();
                        if (pars instanceof IncrementalParser) {
                            final IncrementalParser<?> parser = (IncrementalParser<?>) pars;
                            filters.add(parser.getFileFilter());
                        }
                    }
                }
            }
            fileFilter = new OrFileFilter(filters);
        }
        return fileFilter;
    }