Return if this path has been visited before.
@param path topic path, may contain a fragment
@return true if has been visited
509345
public boolean isVisited(final URI path) {
        final URI localPath = stripFragment(path).normalize();
        return visitSet.contains(localPath);
    }
651016
protected boolean isExcluded(CmsObject cms, String path) {

        List<String> excludes = getExcludes(cms);
        // now check if the current link start with one of the exclude links
        for (int i = 0; i < excludes.size(); i++) {
            if (path.startsWith(excludes.get(i))) {
                return true;
            }
        }
        return false;
    }
634578
public boolean nodeExists(String path) throws ZooKeeperException {
        try {
            Stat stat = curatorFramework.checkExists().forPath(path);
            return stat != null;
        } catch (Exception e) {
            if (e instanceof ZooKeeperException) {
                throw (ZooKeeperException) e;
            } else {
                throw new ZooKeeperException(e);
            }
        }
    }
589129
function hasIt(path) {
            var areITFound = false;
            if (path.node.name === IT) {
              return true;
            }
            path.traverse({
              Identifier: function Identifier(path) {
                if (path.node.name === IT) {
                  areITFound = true;
                }
              }
            });
            return areITFound;
          }
1156201
public boolean isHubPath(String path) throws IOException {
        if ("/".equals(path))
            return true;
        for (String root : getNonHubRoots()) {
            if (root.startsWith("*")) {
                if (path.endsWith(root.substring(1)))
                    return false;
            }
            else if (path.equals(root) || path.startsWith(root + "/")) {
                return false;
            }
        }
        return true;
    }
722053
public boolean matches(String path) {
        List<String> segments;

        segments = Filesystem.SEPARATOR.split(path);
        if (segments.size() < minDepth || segments.size() > maxDepth) {
            return false;
        }
        if (predicates.size() > 0) {
            throw new UnsupportedOperationException("cannot match with predicates");
        }
        return matches(0, segments, new ArrayList<>(includes), new ArrayList<>(excludes));
    }
1126878
@Override
    public boolean contains(ArchivePath path) {
        Validate.notNull(path, "No path was specified");

        boolean found = content.containsKey(path);
        if (!found) {
            found = nestedContains(path);
        }
        return found;
    }
135100
public boolean remove(String path) {
        jsonStore.clear();
        return JSONPath.remove(jsonObject, checkPath(path));
    }
1072316
public Optional<Boolean> hasValidFallback(String path)
  {
    return resources.get(path) != null ? Optional.of(resources.get(path).hasValidItemFallback)
        : Optional.<Boolean> absent();
  }
1333199
protected boolean isValidPath(String path) {
        if (path == null) {
            return false;
        }
        
        if (!PATH_PATTERN.matcher(path).matches()) {
            return false;
        }
        
        try {
            URI uri = new URI(null,null,path,null);
            String norm = uri.normalize().getPath();
            if (norm.startsWith("/../") // Trying to go via the parent dir 
                    || norm.equals("/..")) {   // Trying to go to the parent dir
                return false;
            }
        } catch (URISyntaxException e) {
            return false;
        }
        
        int slash2Count = countToken("//", path);
        if (isOff(ALLOW_2_SLASHES) && (slash2Count > 0)) {
            return false;
        }
        
        return true;
    }
289481
public boolean contains(String path) {
        boolean result = false;
        FileName fn = new FileName(path);
        if (fn.getPath().startsWith(getPath())) {
            result = true;
        }
        return result;
    }
1345538
public long getLastModified(String path) throws GetLastModifiedException {
        String hash;
        Content content;

        hash = hashCache.probe(path);
        if (hash != null) {
            content = contentCache.probe(hash);
            if (content != null) {
                return content.lastModified;
            }
        }
        return -1;
    }
560438
private boolean isWar(String path) {
        String currentDir = Paths.get(".").toAbsolutePath().normalize().toString();
        String classesDirPath = Paths.get(path).toAbsolutePath().normalize().toString();
        return classesDirPath.startsWith(currentDir);
    }
560790
protected boolean createDirectoryIfNotExists(Path path) throws IOException {
        if(!Files.exists(path)) {
            Files.createDirectories(path);
            return true;
        }
        else {
            return false;
        }
    }
734825
public boolean isTemporaryPath(String path) {
    for (String tempPath : tempIdentifiers) {
      String[] tempPathComponents = tempPath.split("/");
      if (tempPathComponents.length > 0
          && path != null && path.contains(tempPathComponents[0].replace("ID", ""))) {
        return true;
      }
    }
    return false;
  }
889845
protected void checkPath(Path path) {
    URI thisUri = this.getUri();
    URI thatUri = path.toUri();
    String thatAuthority = thatUri.getAuthority();
    if (thatUri.getScheme() != null
        && thatUri.getScheme().equalsIgnoreCase(thisUri.getScheme())
        && thatUri.getPort() == NameNode.DEFAULT_PORT
        && thisUri.getPort() == -1
        && thatAuthority.substring(0,thatAuthority.indexOf(":"))
        .equalsIgnoreCase(thisUri.getAuthority()))
      return;
    super.checkPath(path);
  }
1311819
public boolean isExcluded(String path) {

        path = normalizePath(path);
        List<String> pathList = new ArrayList<String>(m_allPaths);
        // m_allPaths is already sorted, we need the reverse ordering so children come before their parents
        // (we want to find the deepest parent folder of 'path' that is marked as include/exclude)
        Collections.reverse(pathList);
        for (String pathInList : pathList) {
            if (CmsStringUtil.isPrefixPath(pathInList, path)) {
                return m_excludes.contains(pathInList);
            }
        }
        return false;
    }