Compiles a JsonPath

@param jsonPath to compile
@param filters  filters to be applied to the filter place holders  [?] in the path
@return compiled JsonPath
543081
public static JsonPath compile(String jsonPath, Predicate... filters) {
        notEmpty(jsonPath, "json can not be null or empty");

        return new JsonPath(jsonPath, filters);
    }
633023
public static <T> T withFilePathOrClasspath(
            String resourceFilePathOrClasspath,
            TypeReference<T> typeReference) {
        return withJsonString(JMResources
                        .getStringWithFilePathOrClasspath(resourceFilePathOrClasspath),
                typeReference);
    }
645419
public static MessageFilter compile(String filter) throws InvalidFilterException {
        MessageFilterParser parser = MessageFilterParser.createParser(filter);
        MessageFilterTranslatable t = parseToTranslatable(parser);
        MessageFilter translate = t.translate();
        if (BaseMessageFilter.class.isAssignableFrom(translate.getClass())) {
            ((BaseMessageFilter) translate).setOriginalDslString(filter);
        }

        return translate;
    }
118141
public Object collectOne(String json, JsonPath... paths) {
        return collectOne(json, Object.class, paths);
    }
537164
@Override
    public List<String> setTargetHostsFromJsonPath(String jsonPath,
            String sourcePath, HostsSourceType sourceType)
            throws TargetHostsLoadException {

        List<String> targetHosts = new ArrayList<String>();
        try {
            String content = getContentFromPath(sourcePath, sourceType);
            targetHosts = JsonPath.read(content, jsonPath);

        } catch (IOException e) {
            throw new TargetHostsLoadException("IEException when reading  "
                    + sourcePath, e);
        }

        return targetHosts;
    }
453150
public static <T> Matcher<T> jsonPartMatches(String path, Matcher<?> matcher) {
        return new MatcherApplyingMatcher<>(path, matcher);
    }
300838
public XMLResource xml(JSONPathQuery path) throws Exception {
		Object jsonValue = path.eval(this);
		return xml(jsonValue.toString());
	}
268798
public CmsRelationFilter filterPath(String path) {

        CmsRelationFilter filter = (CmsRelationFilter)clone();
        filter.m_path = path;
        return filter;
    }
619901
public void addFeaturePath( String featurePath, String filter ) {
        if (!featurePaths.contains(featurePath)) {
            featurePaths.add(featurePath);
            if (filter == null) {
                filter = "";
            }
            featureFilter.add(filter);
        }
    }
979380
@Deprecated
	protected static ArrayList<String> findJsonFiles(Path root, String subdir) throws IOException {
		logger.debug("Looking for json files in classpath under [{}/{}].", root, subdir);

		final ArrayList<String> jsonFiles = new ArrayList<>();
		final Path indexDir = root.resolve(subdir);
		if (Files.exists(indexDir)) {
			Files.walkFileTree(indexDir, new SimpleFileVisitor<Path>() {
				@Override
				public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
					// We have now files. They could be type, settings, templates...
					String jsonFile = indexDir.relativize(file).toString();

					if (jsonFile.equals(Defaults.IndexSettingsFileName) ||
							jsonFile.equals(Defaults.UpdateIndexSettingsFileName)) {
						logger.trace("ignoring: [{}]", jsonFile);
						return CONTINUE;
					}
					jsonFile = jsonFile.substring(0, jsonFile.lastIndexOf(Defaults.JsonFileExtension));

					jsonFiles.add(jsonFile);
					logger.trace("json found: [{}]", jsonFile);
					return CONTINUE;
				}
			});
		} else {
			logger.trace("[{}] does not exist in [{}].", subdir, root);
		}

		return jsonFiles;
	}
177365
@Override
    public List<T> readWithFilter(ReadFilter filter) {
        if (filter == null) {
            filter = new ReadFilter();
        }
        JSONObject where = filter.getWhere();
        scanForNestedObjectsInWhereClause(where);
        List<T> results = new ArrayList<T>(data.values());

        filterData(results, where);
        results = pageData(results, filter.getLimit(), filter.getOffset());
        return results;
    }
331953
public static Stream<Path> getChildFilePathStream(Path path,
			Predicate<Path> filter) {
		return getChildrenPathStream(path)
				.filter(RegularFileFilter.and(filter));
	}
962643
def p_jsonpath_sort(self, p):
        "'"
        sort = _iterable.SortedThis(p[3])
        p[0] = jsonpath_rw.Child(p[1], sort)
1160751
public static List<FileStatus> listPathsRecursively(FileSystem fs, Path path, PathFilter fileFilter)
      throws IOException {
    return listPathsRecursivelyHelper(fs, Lists.<FileStatus>newArrayList(), fs.getFileStatus(path), fileFilter);
  }
885255
public Collection<Object> collectAll(String json, JsonPath... paths) {
        return collectAll(json, Object.class, paths);
    }
1216687
public String compile(String resourcePath, String coffeeScriptSource) {

		String result = null;
		try {
			result = (String) jsEngine.invokeMethod(coffeeScript, "compile", coffeeScriptSource, options);
		} catch (NoSuchMethodException | ScriptException e) {
			throw new BundlingProcessException(e);
		}

		return result;
	}
1306775
static FilterImpl create(final String path, final Filter filter) {
        return create(path, DEFAULT_ACCEPT_TYPE, filter);
    }