|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object org.schmant.task.at4j.bzip2.AbstractBZip2WritableFileProxy
public abstract class AbstractBZip2WritableFileProxy
This is an abstract base class for bzip2 writable file proxies.
Constructor Summary | |
---|---|
protected |
AbstractBZip2WritableFileProxy(Object proxied)
|
protected |
AbstractBZip2WritableFileProxy(Object proxied,
BZip2WritableFileSettings settings)
The proxied file. |
protected |
AbstractBZip2WritableFileProxy(Object proxied,
CompressionLevel level)
|
protected |
AbstractBZip2WritableFileProxy(Object proxied,
int blockSize)
|
Method Summary | |
---|---|
protected WritableFile |
getFile()
|
protected abstract WritableFile |
getFileFromArgumentInterpreter(Object proxied)
|
EntityLock |
getWriteLock()
Get the write lock without locking it. |
boolean |
isWriteLockedByCurrentThread()
Does the calling thread hold a write lock for the lockable object (this)? |
EntityLock |
lockForWriting()
Lock the object for writing and return the lock. |
WritableByteChannel |
openChannelForAppend()
Open a WritableByteChannel for appending to the file. |
WritableByteChannel |
openChannelForWrite()
Open a WritableByteChannel for writing on the file. |
OutputStream |
openForAppend()
Open the file for appending. |
OutputStream |
openForWrite()
Opens the file for writing. |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Constructor Detail |
---|
protected AbstractBZip2WritableFileProxy(Object proxied)
protected AbstractBZip2WritableFileProxy(Object proxied, int blockSize)
protected AbstractBZip2WritableFileProxy(Object proxied, BZip2WritableFileSettings settings)
proxied
- The proxied file.settings
- bzip2 settingsprotected AbstractBZip2WritableFileProxy(Object proxied, CompressionLevel level)
Method Detail |
---|
protected abstract WritableFile getFileFromArgumentInterpreter(Object proxied)
protected WritableFile getFile()
public WritableByteChannel openChannelForAppend() throws UnsupportedOperationException
WritableFile
WritableByteChannel
for appending to the file. The
semantics of this method is the same as for WritableFile.openForAppend()
.
openChannelForAppend
in interface WritableFile
WritableByteChannel
. The channel must be closed
by the caller. The returned channel may be a
GatheringByteChannel
, but that is not required.
UnsupportedOperationException
- Always!public WritableByteChannel openChannelForWrite() throws WriteLockRequiredException, AccessDeniedException, ReadOnlyException
WritableFile
WritableByteChannel
for writing on the file. The semantics
of this method is the same as for WritableFile.openForWrite()
.
openChannelForWrite
in interface WritableFile
WritableByteChannel
. The channel must be closed
by the caller. The returned channel may be a
GatheringByteChannel
, but that is not required.
WriteLockRequiredException
- If the client does not have a write
lock for the file.
AccessDeniedException
- If the client does not have write access to
the file.
ReadOnlyException
- If the file system is read-only.WritableFile.openForWrite()
,
WritableFile.openChannelForAppend()
public OutputStream openForAppend() throws UnsupportedOperationException
WritableFile
WritableFile.openForWrite()
to delete the previous contents before
writing. This requires that the file supports the
FCAppendable
capability (and/or that the
file system supports the FSCAppendableFiles
capability.
The caller is responsible for closing the stream.
When two appending output streams are open on the same file, one stream will not overwrite contents written by the other stream. Compare this with the behavior of one writing and one appending stream.
Although a write lock on the file is required for the execution thread
opening the stream, the stream itself is not protected from access by
other threads. It can be protected by wrapping it in a
LockAwareWritableByteChannel
.
openForAppend
in interface WritableFile
OutputStream
to write to. The stream must be closed by
the caller.
UnsupportedOperationException
- Always!WritableFile.openForWrite()
,
WritableFile.openChannelForAppend()
public OutputStream openForWrite() throws WriteLockRequiredException, AccessDeniedException, ReadOnlyException
WritableFile
WritableFile.openForAppend()
to append to the file.
The caller is responsible for closing the stream.
When two output streams, one writing and one appending are open on the same file, the stream opened for write will ignore the contents written by the other stream and the content written by the other stream will be overwritten. When two or more appending streams are opened on a file, a stream will not overwrite the content written by the other streams.
Although a write lock on the file is required for the execution thread
opening the stream, the stream itself is not protected from access by
other threads. It can be protected by wrapping it in a
LockAwareOutputStream
.
openForWrite
in interface WritableFile
OutputStream
to write to. The stream must be closed by
the caller.
WriteLockRequiredException
- If the client does not have a write
lock for the file.
AccessDeniedException
- If the client does not have write access to
the file.
ReadOnlyException
- If the file system is read-only.WritableFile.openForAppend()
,
WritableFile.openChannelForWrite()
public EntityLock getWriteLock()
WriteLockable
This method always returns a lock, even if the object's file system is not locking or if the object is read only.
getWriteLock
in interface WriteLockable
public boolean isWriteLockedByCurrentThread()
WriteLockable
isWriteLockedByCurrentThread
in interface WriteLockable
true
if the lockable object is write locked by the
current thread.public EntityLock lockForWriting() throws LockTimeoutException
WriteLockable
EntityLockAdapterFactory
and
LockAcquiringStrategy
used. If this is called on an object that
is somehow connected to an Entity
object, that entity's file
systems' lock adapter factory and lock acquiring strategy is used. A
write lock can be downgraded to a read lock (by calling
ReadLockable.lockForReading()
and then releasing the write lock).
An entity in a locking read only file system may still be locked for writing.
For more discussions on locks and locking, see Entity
and
FileSystem
.
This method always returns a lock, even if the file system is not locking.
lockForWriting
in interface WriteLockable
LockTimeoutException
- If the lock acquiring timed out. (It is up
to the LockAcquiringStrategy
to decide if lock acquiring can time
out.)
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |