/**
* Acquires an open file slot for the calling instance and registers it accordingly. Transparently
* closes the last opened file of another instance, if limit is to be exceeded.
*
* @param customer Calling instance requiring an open file slot(<code>this</code> reference)
* @throws IOException
*/
protected static synchronized void retrieveOpenFileSlot(ManagedRandomAccessFile customer)
throws IOException {
// probe, whether maximum open files limit has been exceeded
if (openFilesCounter >= maxOpenFiles) {
// close the last opened file
ManagedRandomAccessFile victim = (ManagedRandomAccessFile) openFilesList.remove(0);
victim.closeHandle();
// adjust counter
openFilesCounter--;
}
// provide slot and save reference
openFilesList.add(customer);
// adjust counter
openFilesCounter++;
}
/**
* Creates a new managed instance, which is based on the given file. The created instance will be
* an exact copy, or clone, of the given template instance. Modifications are not synchronized
* between template and clone, i.e. they behave as truly separate instances that are only exactly
* the same after construction.
*
* @param template The template to create a clone from.
* @param aFile File which is to be backing the clone to be created.
* @throws IOException
*/
public ManagedRandomAccessFile(ManagedRandomAccessFile template) throws IOException {
file = ManagedRandomAccessFile.createTempFile();
raf = null;
currentFilePointer = template.currentFilePointer;
isOpen = false;
copyFile(template.file, file);
}
/**
* Closes this instance virtually (flushes and releases the managed file)
*
* @throws IOException
*/
public synchronized void close() throws IOException {
if (isOpen) {
raf().close();
ManagedRandomAccessFile.releaseOpenFileSlot(this);
isOpen = false;
}
}
/**
* Creates a new managed instance, which is based on the given file.
*
* @param aFile The file which to access in a random fashion.
* @throws IOException
*/
public ManagedRandomAccessFile() throws IOException {
// initialize
file = ManagedRandomAccessFile.createTempFile();
raf = null;
currentFilePointer = 0;
isOpen = false;
}
/**
* Re-opens the managed random access file, implies retrieving an open file slot from the static
* management facilities.
*/
protected synchronized void reOpen() throws IOException {
// retrieve open file slot
ManagedRandomAccessFile.retrieveOpenFileSlot(this);
// adjust internal state
isOpen = true;
// restore random access file
raf = new RandomAccessFile(file, "rw");
}
