/** * If this object store implementation is exclusively working on a set of * object states, then this method will check a file cache first. * Otherwise, we must go back to the file system each time to check the * status of the file. * * If we add a FileDescriptor cache a la the C++ version then we would * be able to get rid of the state cache and simply check to see if we * had a fd for it. */ protected final boolean exists (String path) { if (super.shareStatus == ObjectStore.OS_UNSHARED) { if (FileSystemStore.fileCache.get(path) != null) return true; } /* * If here then we need to check the file system. If there, we will * put it into the cache (if appropriate). */ File f = new File(path); boolean doesExist = f.exists(); if (doesExist) addToCache(path); return doesExist; }
/** * If this object store implementation is exclusively working on a set of * object states, then this method will check a file cache first. * Otherwise, we must go back to the file system each time to check the * status of the file. * * If we add a FileDescriptor cache a la the C++ version then we would * be able to get rid of the state cache and simply check to see if we * had a fd for it. */ protected final boolean exists (String path) { if (super.shareStatus == StateType.OS_UNSHARED) { if (FileSystemStore.fileCache.get(path) != null) return true; } /* * If here then we need to check the file system. If there, we will * put it into the cache (if appropriate). */ File f = new File(path); // files created but not yet written are normally considered to not exist yet. JBTM-821 boolean doesExist = (f.exists() && (scanZeroLengthFiles || f.length() > 0)); if (doesExist) addToCache(path); return doesExist; }
/** * If this object store implementation is exclusively working on a set of * object states, then this method will check a file cache first. * Otherwise, we must go back to the file system each time to check the * status of the file. * * If we add a FileDescriptor cache a la the C++ version then we would * be able to get rid of the state cache and simply check to see if we * had a fd for it. */ protected final boolean exists (String path) { if (super.shareStatus == StateType.OS_UNSHARED) { if (FileSystemStore.fileCache.get(path) != null) return true; } /* * If here then we need to check the file system. If there, we will * put it into the cache (if appropriate). */ File f = new File(path); // files created but not yet written are normally considered to not exist yet. JBTM-821 boolean doesExist = (f.exists() && (scanZeroLengthFiles || f.length() > 0)); if (doesExist) addToCache(path); return doesExist; }
/** * If this object store implementation is exclusively working on a set of * object states, then this method will check a file cache first. * Otherwise, we must go back to the file system each time to check the * status of the file. * * If we add a FileDescriptor cache a la the C++ version then we would * be able to get rid of the state cache and simply check to see if we * had a fd for it. */ protected final boolean exists (String path) { if (super.shareStatus == StateType.OS_UNSHARED) { if (FileSystemStore.fileCache.get(path) != null) return true; } /* * If here then we need to check the file system. If there, we will * put it into the cache (if appropriate). */ File f = new File(path); // files created but not yet written are normally considered to not exist yet. JBTM-821 boolean doesExist = (f.exists() && (scanZeroLengthFiles || f.length() > 0)); if (doesExist) addToCache(path); return doesExist; }
/** * If this object store implementation is exclusively working on a set of * object states, then this method will check a file cache first. * Otherwise, we must go back to the file system each time to check the * status of the file. * * If we add a FileDescriptor cache a la the C++ version then we would * be able to get rid of the state cache and simply check to see if we * had a fd for it. */ protected final boolean exists (String path) { if (super.shareStatus == StateType.OS_UNSHARED) { if (FileSystemStore.fileCache.get(path) != null) return true; } /* * If here then we need to check the file system. If there, we will * put it into the cache (if appropriate). */ File f = new File(path); // files created but not yet written are normally considered to not exist yet. JBTM-821 boolean doesExist = (f.exists() && (scanZeroLengthFiles || f.length() > 0)); if (doesExist) addToCache(path); return doesExist; }
/** * If this object store implementation is exclusively working on a set of * object states, then this method will check a file cache first. * Otherwise, we must go back to the file system each time to check the * status of the file. * * If we add a FileDescriptor cache a la the C++ version then we would * be able to get rid of the state cache and simply check to see if we * had a fd for it. */ protected final boolean exists (String path) { if (super.shareStatus == StateType.OS_UNSHARED) { if (FileSystemStore.fileCache.get(path) != null) return true; } /* * If here then we need to check the file system. If there, we will * put it into the cache (if appropriate). */ File f = new File(path); // files created but not yet written are normally considered to not exist yet. JBTM-821 boolean doesExist = (f.exists() && (scanZeroLengthFiles || f.length() > 0)); if (doesExist) addToCache(path); return doesExist; }
/** * If this object store implementation is exclusively working on a set of * object states, then this method will check a file cache first. * Otherwise, we must go back to the file system each time to check the * status of the file. * * If we add a FileDescriptor cache a la the C++ version then we would * be able to get rid of the state cache and simply check to see if we * had a fd for it. */ protected final boolean exists (String path) { if (super.shareStatus == StateType.OS_UNSHARED) { if (FileSystemStore.fileCache.get(path) != null) return true; } /* * If here then we need to check the file system. If there, we will * put it into the cache (if appropriate). */ File f = new File(path); // files created but not yet written are normally considered to not exist yet. JBTM-821 boolean doesExist = (f.exists() && (scanZeroLengthFiles || f.length() > 0)); if (doesExist) addToCache(path); return doesExist; }
/** * If this object store implementation is exclusively working on a set of * object states, then this method will check a file cache first. * Otherwise, we must go back to the file system each time to check the * status of the file. * * If we add a FileDescriptor cache a la the C++ version then we would * be able to get rid of the state cache and simply check to see if we * had a fd for it. */ protected final boolean exists (String path) { if (super.shareStatus == StateType.OS_UNSHARED) { if (FileSystemStore.fileCache.get(path) != null) return true; } /* * If here then we need to check the file system. If there, we will * put it into the cache (if appropriate). */ File f = new File(path); // files created but not yet written are normally considered to not exist yet. JBTM-821 boolean doesExist = (f.exists() && (scanZeroLengthFiles || f.length() > 0)); if (doesExist) addToCache(path); return doesExist; }
/** * If this object store implementation is exclusively working on a set of * object states, then this method will check a file cache first. * Otherwise, we must go back to the file system each time to check the * status of the file. * * If we add a FileDescriptor cache a la the C++ version then we would * be able to get rid of the state cache and simply check to see if we * had a fd for it. */ protected final boolean exists (String path) { if (super.shareStatus == StateType.OS_UNSHARED) { if (FileSystemStore.fileCache.get(path) != null) return true; } /* * If here then we need to check the file system. If there, we will * put it into the cache (if appropriate). */ File f = new File(path); // files created but not yet written are normally considered to not exist yet. JBTM-821 boolean doesExist = (f.exists() && (scanZeroLengthFiles || f.length() > 0)); if (doesExist) addToCache(path); return doesExist; }
/** * If this object store implementation is exclusively working on a set of * object states, then this method will check a file cache first. * Otherwise, we must go back to the file system each time to check the * status of the file. * * If we add a FileDescriptor cache a la the C++ version then we would * be able to get rid of the state cache and simply check to see if we * had a fd for it. */ protected final boolean exists (String path) { if (super.shareStatus == StateType.OS_UNSHARED) { if (FileSystemStore.fileCache.get(path) != null) return true; } /* * If here then we need to check the file system. If there, we will * put it into the cache (if appropriate). */ File f = new File(path); // files created but not yet written are normally considered to not exist yet. JBTM-821 boolean doesExist = (f.exists() && (scanZeroLengthFiles || f.length() > 0)); if (doesExist) addToCache(path); return doesExist; }
/** * If this object store implementation is exclusively working on a set of * object states, then this method will check a file cache first. * Otherwise, we must go back to the file system each time to check the * status of the file. * * If we add a FileDescriptor cache a la the C++ version then we would * be able to get rid of the state cache and simply check to see if we * had a fd for it. */ protected final boolean exists (String path) { if (super.shareStatus == StateType.OS_UNSHARED) { if (FileSystemStore.fileCache.get(path) != null) return true; } /* * If here then we need to check the file system. If there, we will * put it into the cache (if appropriate). */ File f = new File(path); // files created but not yet written are normally considered to not exist yet. JBTM-821 boolean doesExist = (f.exists() && (scanZeroLengthFiles || f.length() > 0)); if (doesExist) addToCache(path); return doesExist; }
super.addToCache(path1); super.addToCache(path1);
super.addToCache(path1); super.addToCache(path1);
super.addToCache(path1); super.addToCache(path1);
super.addToCache(path2); super.addToCache(path2);
super.addToCache(path1); super.addToCache(path1);
super.addToCache(path2); super.addToCache(path2);
super.addToCache(path1); super.addToCache(path1);
super.addToCache(path1); super.addToCache(path1);
super.addToCache(filename); super.removeFromCache(shadow);