| Methods Summary |
|---|
| public void | addListener(DiskManagerFileInfoListener listener)
if ( listeners == null ){
listeners = new CopyOnWriteList();
}
synchronized( listeners ){
if ( listeners.getList().contains( listener )){
return;
}
}
listeners.add( listener );
new Runnable()
{
private long file_start;
private long file_end;
private long current_write_start = -1;
private long current_write_end = -1;
private long current_check_start = -1;
private long current_check_end = -1;
public void
run()
{
TOTorrentFile[] tfs = torrent_file.getTorrent().getFiles();
long torrent_offset = 0;
for (int i=0;i<file_index;i++){
torrent_offset += tfs[i].getLength();
}
file_start = torrent_offset;
file_end = file_start + torrent_file.getLength();
DiskManagerPiece[] pieces = diskManager.getPieces();
int first_piece = getFirstPieceNumber();
int last_piece = getLastPieceNumber();
long piece_size = torrent_file.getTorrent().getPieceLength();
for (int i=first_piece;i<=last_piece;i++){
long piece_offset = piece_size * i;
DiskManagerPiece piece = pieces[i];
if ( piece.isDone()){
long bit_start = piece_offset;
long bit_end = bit_start + piece.getLength();
bitWritten( bit_start, bit_end, true );
}else{
int block_offset = 0;
for (int j=0;j<piece.getNbBlocks();j++){
int block_size = piece.getBlockSize(j);
if ( piece.isWritten(j)){
long bit_start = piece_offset + block_offset;
long bit_end = bit_start + block_size;
bitWritten( bit_start, bit_end, false );
}
block_offset += block_size;
}
}
}
bitWritten( -1, -1, false );
}
protected void
bitWritten(
long bit_start,
long bit_end,
boolean checked )
{
if ( current_write_start == -1 ){
current_write_start = bit_start;
current_write_end = bit_end;
}else if ( current_write_end == bit_start ){
current_write_end = bit_end;
}else{
if ( current_write_start < file_start ){
current_write_start = file_start;
}
if ( current_write_end > file_end ){
current_write_end = file_end;
}
if ( current_write_start < current_write_end ){
try{
listener.dataWritten( current_write_start-file_start, current_write_end-current_write_start );
}catch( Throwable e ){
Debug.printStackTrace(e);
}
}
current_write_start = bit_start;
current_write_end = bit_end;
}
// checked case
if ( checked && current_check_start == -1 ){
current_check_start = bit_start;
current_check_end = bit_end;
}else if ( checked && current_check_end == bit_start ){
current_check_end = bit_end;
}else{
if ( current_check_start < file_start ){
current_check_start = file_start;
}
if ( current_check_end > file_end ){
current_check_end = file_end;
}
if ( current_check_start < current_check_end ){
try{
listener.dataChecked( current_check_start-file_start, current_check_end-current_check_start );
}catch( Throwable e ){
Debug.printStackTrace(e);
}
}
if ( checked ){
current_check_start = bit_start;
current_check_end = bit_end;
}else{
current_check_start = -1;
current_check_end = -1;
}
}
}
}.run();
|
| public void | close()
// this doesn't need to do anything as overall closure is handled by the disk manager closing
|
| public void | dataChecked(long offset, long size)
if ( listeners != null ){
Iterator it = listeners.iterator();
while( it.hasNext()){
try{
((DiskManagerFileInfoListener)it.next()).dataChecked( offset, size );
}catch( Throwable e ){
Debug.printStackTrace(e);
}
}
}
|
| public void | dataWritten(long offset, long size)
if ( listeners != null ){
Iterator it = listeners.iterator();
while( it.hasNext()){
try{
((DiskManagerFileInfoListener)it.next()).dataWritten( offset, size );
}catch( Throwable e ){
Debug.printStackTrace(e);
}
}
}
|
| public void | flushCache()
cache_file.flushCache();
|
| public boolean | forceNoCache()
return( diskManager.forceNoCache());
|
| public int | getAccessMode()
int mode = cache_file.getAccessMode();
return( mode == CacheFile.CF_READ?DiskManagerFileInfo.READ:DiskManagerFileInfo.WRITE);
|
| public CacheFile | getCacheFile()
return( cache_file );
|
| public java.io.File | getCacheFileControlFile(java.lang.String name)
return( diskManager.getDownloadState().getStateFile( name ));
|
| public java.lang.String | getCacheFileOwnerName()
return( diskManager.getInternalName());
|
| public org.gudy.azureus2.core3.torrent.TOTorrentFile | getCacheFileTorrentFile()
return( torrent_file );
|
| public DiskManager | getDiskManager()
return diskManager;
|
| public org.gudy.azureus2.core3.download.DownloadManager | getDownloadManager()
DownloadManagerState state = diskManager.getDownloadState();
if ( state == null ){
return( null );
}
return( state.getDownloadManager());
|
| public long | getDownloaded()
return downloaded;
|
| public java.lang.String | getExtension()
return extension;
|
| public java.io.File | getFile(boolean follow_link)
if ( follow_link ){
File res = getLink();
if ( res != null ){
return( res );
}
}
return( file );
|
| public int | getFirstPieceNumber()
return torrent_file.getFirstPieceNumber();
|
| public int | getIndex()
return( file_index );
|
| public int | getLastPieceNumber()
return torrent_file.getLastPieceNumber();
|
| public long | getLength()
return torrent_file.getLength();
|
| public java.io.File | getLink()
return( diskManager.getDownloadState().getFileLink( getFile( false )));
|
| public int | getNbPieces()
return torrent_file.getNumberOfPieces();
|
| public int | getStorageType()
String[] types = diskManager.getStorageTypes();
return( types[file_index].equals( "L")?ST_LINEAR:ST_COMPACT );
|
| public org.gudy.azureus2.core3.torrent.TOTorrentFile | getTorrentFile()
return( torrent_file );
|
| protected boolean | isLinked()
return( getLink() != null );
|
| public boolean | isPriority()
return priority;
|
| public boolean | isSkipped()
return skipped;
|
| protected void | moveFile(java.io.File newFile, boolean link_only)
if ( !link_only ){
cache_file.moveFile( newFile );
}
file = newFile;
|
| public DirectByteBuffer | read(long offset, int length)
DirectByteBuffer buffer =
DirectByteBufferPool.getBuffer( DirectByteBuffer.AL_DM_READ, length );
try{
cache_file.read( buffer, offset, CacheFile.CP_READ_CACHE );
}catch( Throwable e ){
buffer.returnToPool();
Debug.printStackTrace(e);
throw( new IOException( e.getMessage()));
}
return( buffer );
|
| public void | removeListener(DiskManagerFileInfoListener listener)
listeners.remove( listener );
|
| public void | setAccessMode(int mode)
int old_mode = cache_file.getAccessMode();
cache_file.setAccessMode( mode==DiskManagerFileInfo.READ?CacheFile.CF_READ:CacheFile.CF_WRITE );
if ( old_mode != mode ){
diskManager.accessModeChanged( this, old_mode, mode );
}
|
| public void | setDownloaded(long l)
downloaded = l;
|
| public void | setExtension(java.lang.String string)
extension = string;
|
| public boolean | setLink(java.io.File link_destination)
Debug.out( "setLink: download must be stopped" );
return( false );
|
| public boolean | setLinkAtomic(java.io.File link_destination)
Debug.out( "setLink: download must be stopped" );
return( false );
|
| public void | setPriority(boolean b)
priority = b;
diskManager.priorityChanged( this );
|
| public void | setSkipped(boolean _skipped)
// currently a non-skipped file must be linear
if ( !_skipped && getStorageType() == ST_COMPACT ){
if ( !setStorageType( ST_LINEAR )){
return;
}
}
skipped = _skipped;
diskManager.skippedFileSetChanged( this );
|
| public boolean | setStorageType(int type)
String[] types = diskManager.getStorageTypes();
int old_type = types[file_index].equals( "L")?ST_LINEAR:ST_COMPACT;
if ( type == old_type ){
return( true );
}
if ( type == ST_COMPACT ){
Debug.out( "Download must be stopped for linear -> compact conversion" );
return( false );
}
boolean set_skipped = false; // currently compact files must be skipped
try{
cache_file.setStorageType( type==ST_LINEAR?CacheFile.CT_LINEAR:CacheFile.CT_COMPACT );
set_skipped = type == ST_COMPACT && !isSkipped();
return( true );
}catch( Throwable e ){
Debug.printStackTrace(e);
diskManager.setFailed( this, "Failed to change storage type for '" + getFile(true) + "': " + Debug.getNestedExceptionMessage(e));
return( false );
}finally{
types[file_index] = cache_file.getStorageType()==CacheFile.CT_LINEAR?"L":"C";
DownloadManagerState dm_state = diskManager.getDownloadState();
dm_state.setListAttribute( DownloadManagerState.AT_FILE_STORE_TYPES, types );
dm_state.save();
if ( set_skipped ){
setSkipped( true );
}
}
|
