Indicates whether the given item exists.

@param path Path of the item to check.
@return true if the given item exists, false otherwise.
@throws IOException
188357
public boolean exists(URI path)
      throws IOException {
    logger.atFine().log("exists(%s)", path);
    return getFileInfo(path).exists();
  }
1106898
@SuppressWarnings("unchecked")
	@Override
	public boolean isDirectory(String path) {
		Set<String> paths = context.getResourcePaths(path);
		return (null != paths && paths.size() > 0);
	}
1268827
@Override
    public Promise<Boolean> exists(String path) {
        return adapter.toPromise(handler -> vertx.fileSystem().exists(path, handler));
    }
496709
@Override
    public boolean contains(final String path) throws IllegalArgumentException {
        Validate.notNull(path, "Path must be specified");
        return this.contains(ArchivePaths.create(path));
    }
1117914
public boolean exists (HttpServletRequest req, String path)
    {
        return (getMessage(req, path, false) != null);
    }
1193524
public CompletableFuture<Boolean> topicExistsAsync(String path) {
        EntityNameHelper.checkValidTopicName(path);

        CompletableFuture<Boolean> existsFuture = new CompletableFuture<>();
        this.getTopicAsync(path).handleAsync((qd, ex) -> {
            if (ex != null) {
                if (ex instanceof MessagingEntityNotFoundException) {
                    existsFuture.complete(Boolean.FALSE);
                    return false;
                }

                existsFuture.completeExceptionally(ex);
                return false;
            }

            existsFuture.complete(Boolean.TRUE);
            return true;
        }, MessagingFactory.INTERNAL_THREAD_POOL);

        return existsFuture;
    }
1115737
public boolean isPathAvailable(Path path) {
    try {
      Configuration conf = HadoopUtils.newConfiguration();
      FileSystem fs = FileSystem.get(this.getFsURI(), conf);
      if (fs.exists(path)) {
        return true;
      } else {
        log.warn("The data path [" + path + "] is not available on FileSystem: " + this.getFsURI());
        return false;
      }
    } catch (IOException ioe) {
      log.warn("Errors occurred while checking path [" + path + "] existence " + this.getFsURI(), ioe);
      return false;
    }
  }
608052
@Override
  public Stat exists(String path) throws InterruptedException, KeeperException
  {
    return exists(path, false);
  }
827312
private void verifyPathIsOEX(File path) {
    checkNotNull(path);
    checkArgument(path.exists(), "%s does not exist", path.getAbsolutePath());
    checkArgument(!path.isDirectory(), "%s is a directory", path.getAbsolutePath());
    checkArgument(path.getName().endsWith(".oex"), "%s does not end with .oex", path.getName());
  }
932087
@Override
	public boolean exists(String resource, String[] paths) throws IOException {
		for (ResourceLoader loader : loaders) {
			if (loader.exists(resource, paths)) {
				return true;
			}
		}
		return false;
	}
387015
def exists(self, path):
    
    if self._json is None:
      return False

    node = self._json
    path_arr = path.split('.')
    while len(path_arr) > 0:
      path_item = path_arr.pop(0)
      if path_item in node and len(path_arr) == 0:
        return True
      elif path_item in node and len(path_arr) > 0:
        node = node[path_item]
      else:
        return False

    return False
1260641
public static boolean existsEx( Path path, LinkOption... options ) {
        if( Files.exists( path ) ) {
            return true;
        }

        if( options.length == 0 || !options[ 0 ].equals( NOFOLLOW_LINKS ) ) {
            return false;
        }

        try {
            Files.readSymbolicLink( path );
        } catch( IOException e ) {
            return false;
        }

        return true;
    }
127921
def exists(self, path, **kwargs):
        """"""
        try:
            self.get_file_status(path, **kwargs)
            return True
        except HdfsFileNotFoundException:
            return False
446915
function existsSync (path) {
  try {
    Fs.accessSync(Path.resolve(path), Fs.F_OK)
    return true
  } catch (err) {
    return false
  }
}
1323080
public boolean exists(String path) {
        if (path == null) {
            return false;
        }
        for (SubdocOperationResult<OPERATION> result : resultList) {
            if (path.equals(result.path()) && !(result.value() instanceof Exception)) {
                return true;
            }
        }
        return false;
    }
266806
@Override
    public boolean exists(final FedoraSession session, final String path) {
        final Session jcrSession = getJcrSession(session);
        try {
            validatePath(jcrSession, path);
            return jcrSession.nodeExists(path);
        } catch (final IllegalArgumentException e) {
            throw new InvalidResourceIdentifierException("Illegal path: " + path);
        } catch (final RepositoryException e) {
            throw new RepositoryRuntimeException(e);
        }
    }
370337
public boolean exists(String path) {
        Iterator i = vHostTable.keySet().iterator();

        while (i.hasNext()) {
            try {
                String pattern = (String) i.next();
                // System.out.println("Pattern = "+pattern);
                if (path.matches(pattern))
                    return true;
            } catch (Exception e) {
                if (tc.isDebugEnabled()) {
                    Tr.debug(tc, "Caught an exception in exists():", e);
                }
                return false;
            }
        }

        return false;
    }