protected String[] doListFileNames(
      String pathName, FileStoreFilter filter, boolean recurse, boolean exitBranchOnFirstMatch) {
    java.util.ArrayList<String> nameList = null;

    for (StoreLocation location : this.readLocations) {
      // If the path name is null, then just search from the root of each location. Otherwise search
      // from the
      // named cache path.
      java.io.File dir = location.getFile();
      if (pathName != null) dir = new java.io.File(makeAbsolutePath(dir, pathName));

      // Either the location does not exists, or the speciifed path does not exist under that
      // location. In either
      // case we skip searching this location.
      if (!dir.exists()) continue;

      // Lazily initialize the list of file names. If no location contains the specified path, then
      // the list is
      // not created, and this method will return null.
      if (nameList == null) nameList = new java.util.ArrayList<String>();

      this.doListFileNames(location, dir, filter, recurse, exitBranchOnFirstMatch, nameList);
    }

    if (nameList == null) return null;

    String[] names = new String[nameList.size()];
    nameList.toArray(names);
    return names;
  }
 public java.util.List<? extends java.io.File> getLocations() {
   java.util.ArrayList<java.io.File> locations = new java.util.ArrayList<java.io.File>();
   for (StoreLocation location : this.readLocations) {
     locations.add(location.getFile());
   }
   return locations;
 }
  protected StoreLocation storeLocationFor(String path) {
    java.io.File file = new java.io.File(path);

    for (StoreLocation location : this.readLocations) {
      if (file.equals(location.getFile())) return location;
    }

    return null;
  }
  protected static String storePathForFile(StoreLocation location, java.io.File file) {
    String path = file.getPath();

    if (location != null) {
      String locationPath = location.getFile().getPath();
      if (path.startsWith(locationPath))
        path = path.substring(locationPath.length(), path.length());
    }

    return path;
  }
  public boolean containsFile(String fileName) {
    if (fileName == null) return false;

    for (StoreLocation location : this.readLocations) {
      java.io.File dir = location.getFile();
      java.io.File file;

      if (fileName.startsWith(dir.getAbsolutePath())) file = new java.io.File(fileName);
      else file = makeAbsoluteFile(dir, fileName);

      if (file.exists()) return true;
    }

    return false;
  }
  /**
   * @param fileName the name of the file to find
   * @param checkClassPath if <code>true</code>, the class path is first searched for the file,
   *     otherwise the class path is not searched unless it's one of the explicit paths in the cache
   *     search directories
   * @return a handle to the requested file if it exists in the cache, otherwise null
   * @throws IllegalArgumentException if <code>fileName</code> is null
   */
  public java.net.URL findFile(String fileName, boolean checkClassPath) {
    if (fileName == null) {
      String message = Logging.getMessage("nullValue.FilePathIsNull");
      Logging.logger().severe(message);
      throw new IllegalArgumentException(message);
    }

    if (checkClassPath) {
      java.net.URL url = this.getClass().getClassLoader().getResource(fileName);
      if (url != null) return url;

      // Check for a thread context class loader. This allows the file store to find resources in a
      // case
      // in which different parts of the application are handled by different class loaders.
      ClassLoader tccl = Thread.currentThread().getContextClassLoader();
      if (tccl != null) {
        url = tccl.getResource(fileName);
        if (url != null) return url;
      }
    }

    for (StoreLocation location : this.readLocations) {
      java.io.File dir = location.getFile();
      if (!dir.exists()) continue;

      java.io.File file = new java.io.File(makeAbsolutePath(dir, fileName));
      if (file.exists()) {
        try {
          if (location.isMarkWhenUsed()) markFileUsed(file);
          else markFileUsed(file.getParentFile());

          return file.toURI().toURL();
        } catch (java.net.MalformedURLException e) {
          Logging.logger()
              .log(
                  Level.SEVERE,
                  Logging.getMessage("FileStore.ExceptionCreatingURLForFile", file.getPath()),
                  e);
        }
      }
    }

    return null;
  }