| Methods Summary |
|---|
| public void | close()
if (openFiles == null) {
openFiles = new HashMap();
}
synchronized(openFiles) {
if (noDeleteOpenFile && openFiles.size() > 0) {
// RuntimeException instead of IOException because
// super() does not throw IOException currently:
throw new RuntimeException("MockRAMDirectory: cannot close: there are still open files: " + openFiles);
}
}
|
| public org.apache.lucene.store.IndexOutput | createOutput(java.lang.String name)
if (openFiles == null) {
openFiles = new HashMap();
}
synchronized(openFiles) {
if (noDeleteOpenFile && openFiles.containsKey(name)) {
// RuntimeException instead of IOException because
// super() does not throw IOException currently:
throw new RuntimeException("MockRAMDirectory: file \"" + name + "\" is still open: cannot overwrite");
}
}
RAMFile file = new RAMFile(this);
synchronized (this) {
RAMFile existing = (RAMFile)fileMap.get(name);
if (existing!=null) {
sizeInBytes -= existing.sizeInBytes;
existing.directory = null;
}
fileMap.put(name, file);
}
return new MockRAMOutputStream(this, file);
|
| public synchronized void | deleteFile(java.lang.String name)
synchronized(openFiles) {
if (noDeleteOpenFile && openFiles.containsKey(name)) {
throw new IOException("MockRAMDirectory: file \"" + name + "\" is still open: cannot delete");
}
}
super.deleteFile(name);
|
| public long | getMaxSizeInBytes()
return this.maxSize;
|
| public long | getMaxUsedSizeInBytes()Returns the peek actual storage used (bytes) in this
directory.
return this.maxUsedSize;
|
| public boolean | getNoDeleteOpenFile()
return noDeleteOpenFile;
|
| public double | getRandomIOExceptionRate()
return randomIOExceptionRate;
|
| final long | getRecomputedActualSizeInBytes()Like getRecomputedSizeInBytes(), but, uses actual file
lengths rather than buffer allocations (which are
quantized up to nearest
RAMOutputStream.BUFFER_SIZE (now 1024) bytes.
long size = 0;
Iterator it = fileMap.values().iterator();
while (it.hasNext())
size += ((RAMFile) it.next()).length;
return size;
|
| public final synchronized long | getRecomputedSizeInBytes()Provided for testing purposes. Use sizeInBytes() instead.
long size = 0;
Iterator it = fileMap.values().iterator();
while (it.hasNext())
size += ((RAMFile) it.next()).getSizeInBytes();
return size;
|
| void | maybeThrowIOException()
if (randomIOExceptionRate > 0.0) {
int number = Math.abs(randomState.nextInt() % 1000);
if (number < randomIOExceptionRate*1000) {
throw new IOException("a random IOException");
}
}
|
| public org.apache.lucene.store.IndexInput | openInput(java.lang.String name)
RAMFile file;
synchronized (this) {
file = (RAMFile)fileMap.get(name);
}
if (file == null)
throw new FileNotFoundException(name);
else {
synchronized(openFiles) {
if (openFiles.containsKey(name)) {
Integer v = (Integer) openFiles.get(name);
v = new Integer(v.intValue()+1);
openFiles.put(name, v);
} else {
openFiles.put(name, new Integer(1));
}
}
}
return new MockRAMInputStream(this, name, file);
|
| public void | resetMaxUsedSizeInBytes()
this.maxUsedSize = getRecomputedActualSizeInBytes();
|
| public void | setMaxSizeInBytes(long maxSize)
this.maxSize = maxSize;
|
| public void | setNoDeleteOpenFile(boolean value)Emulate windows whereby deleting an open file is not
allowed (raise IOException).
this.noDeleteOpenFile = value;
|
| public void | setRandomIOExceptionRate(double rate, long seed)If 0.0, no exceptions will be thrown. Else this should
be a double 0.0 - 1.0. We will randomly throw an
IOException on the first write to an OutputStream based
on this probability.
randomIOExceptionRate = rate;
// seed so we have deterministic behaviour:
randomState = new Random(seed);
|
