dmwriterimpl.java

java 文件下载器。可自定义

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space 
// Source File Name:   DMWriterImpl.java

package org.gudy.azureus2.core3.disk.impl.access.impl;

import com.aelitis.azureus.core.diskmanager.access.*;
import com.aelitis.azureus.core.diskmanager.cache.CacheFile;
import com.aelitis.azureus.core.diskmanager.cache.CacheFileManagerException;
import java.io.File;
import java.util.*;
import org.gudy.azureus2.core3.disk.*;
import org.gudy.azureus2.core3.disk.impl.DiskManagerFileInfoImpl;
import org.gudy.azureus2.core3.disk.impl.DiskManagerHelper;
import org.gudy.azureus2.core3.disk.impl.access.DMWriter;
import org.gudy.azureus2.core3.disk.impl.piecemapper.DMPieceList;
import org.gudy.azureus2.core3.disk.impl.piecemapper.DMPieceMapEntry;
import org.gudy.azureus2.core3.logging.*;
import org.gudy.azureus2.core3.util.*;

// Referenced classes of package org.gudy.azureus2.core3.disk.impl.access.impl:
//			DiskManagerWriteRequestImpl

public class DMWriterImpl
	implements DMWriter
{
	protected class requestDispatcher
		implements DiskAccessRequestListener
	{

		private DiskManagerWriteRequest request;
		private DiskManagerWriteRequestListener listener;
		private DirectByteBuffer buffer;
		private List chunks;
		private int chunk_index;
		final DMWriterImpl this$0;

		protected void dispatch()
		{
			try
			{
				if (chunk_index == chunks.size())
					listener.writeCompleted(request);
				else
				if (chunk_index == 1 && chunks.size() > 32)
				{
					for (int i = 1; i < chunks.size(); i++)
					{
						final AESemaphore sem = new AESemaphore("DMW&C:dispatch:asyncReq");
						final Throwable error[] = {
							null
						};
						doRequest(new DiskAccessRequestListener() {

							final AESemaphore val$sem;
							final Throwable val$error[];
							final requestDispatcher this$1;

							public void requestComplete(DiskAccessRequest request)
							{
								sem.release();
							}

							public void requestCancelled(DiskAccessRequest request)
							{
								Debug.out("shouldn't get here");
							}

							public void requestFailed(DiskAccessRequest request, Throwable cause)
							{
								error[0] = cause;
								sem.release();
							}

							public int getPriority()
							{
								return -1;
							}

							public void requestExecuted(long l)
							{
							}

				
				{
					this$1 = requestDispatcher.this;
					sem = aesemaphore;
					error = athrowable;
					super();
				}
						});
						sem.reserve();
						if (error[0] != null)
							throw error[0];
					}

					listener.writeCompleted(request);
				} else
				{
					doRequest(this);
				}
			}
			catch (Throwable e)
			{
				failed(e);
			}
		}

		protected void doRequest(final DiskAccessRequestListener l)
			throws CacheFileManagerException
		{
			Object stuff[] = (Object[])(Object[])chunks.get(chunk_index++);
			final DiskManagerFileInfoImpl file = (DiskManagerFileInfoImpl)stuff[0];
			buffer.limit((byte)7, ((Integer)stuff[2]).intValue());
			if (file.getAccessMode() == 1)
			{
				if (Logger.isEnabled())
					Logger.log(new LogEvent(disk_manager, DMWriterImpl.LOGID, (new StringBuilder()).append("Changing ").append(file.getFile(true).getName()).append(" to read/write").toString()));
				file.setAccessMode(2);
			}
			boolean handover_buffer = chunk_index == chunks.size();
			DiskAccessRequestListener delegate_listener = new DiskAccessRequestListener() {

				final DiskAccessRequestListener val$l;
				final DiskManagerFileInfoImpl val$file;
				final requestDispatcher this$1;

				public void requestComplete(DiskAccessRequest request)
				{
					l.requestComplete(request);
					file.dataWritten(request.getOffset(), request.getSize());
				}

				public void requestCancelled(DiskAccessRequest request)
				{
					l.requestCancelled(request);
				}

				public void requestFailed(DiskAccessRequest request, Throwable cause)
				{
					l.requestFailed(request, cause);
				}

				public int getPriority()
				{
					return -1;
				}

				public void requestExecuted(long l1)
				{
				}

				
				{
					this$1 = requestDispatcher.this;
					l = diskaccessrequestlistener;
					file = diskmanagerfileinfoimpl;
					super();
				}
			};
			disk_access.queueWriteRequest(file.getCacheFile(), ((Long)stuff[1]).longValue(), buffer, handover_buffer, delegate_listener);
		}

		public void requestComplete(DiskAccessRequest request)
		{
			dispatch();
		}

		public void requestCancelled(DiskAccessRequest request)
		{
			Debug.out("shouldn't get here");
		}

		public void requestFailed(DiskAccessRequest request, Throwable cause)
		{
			failed(cause);
		}

		public int getPriority()
		{
			return -1;
		}

		public void requestExecuted(long l)
		{
		}

		protected void failed(Throwable cause)
		{
			buffer.returnToPool();
			listener.writeFailed(request, cause);
		}

		protected requestDispatcher(DiskManagerWriteRequest _request, DiskManagerWriteRequestListener _listener, DirectByteBuffer _buffer, List _chunks)
		{
			this$0 = DMWriterImpl.this;
			super();
			request = _request;
			listener = _listener;
			buffer = _buffer;
			chunks = _chunks;
			dispatch();
		}
	}


	private static final LogIDs LOGID;
	private static final int MIN_ZERO_BLOCK = 0x100000;
	private DiskManagerHelper disk_manager;
	private DiskAccessController disk_access;
	private int async_writes;
	private Set write_requests;
	private AESemaphore async_write_sem;
	private boolean started;
	private volatile boolean stopped;
	private int pieceLength;
	private long totalLength;
	private boolean complete_recheck_in_progress;
	private AEMonitor this_mon;

	public DMWriterImpl(DiskManagerHelper _disk_manager)
	{
		write_requests = new HashSet();
		async_write_sem = new AESemaphore("DMWriter::asyncWrite");
		this_mon = new AEMonitor("DMWriter");
		disk_manager = _disk_manager;
		disk_access = disk_manager.getDiskAccessController();
		pieceLength = disk_manager.getPieceLength();
		totalLength = disk_manager.getTotalLength();
	}

	public void start()
	{
		this_mon.enter();
		if (started)
			throw new RuntimeException("DMWWriter: start while started");
		if (stopped)
			throw new RuntimeException("DMWWriter: start after stopped");
		started = true;
		this_mon.exit();
		break MISSING_BLOCK_LABEL_66;
		Exception exception;
		exception;
		this_mon.exit();
		throw exception;
	}

	public void stop()
	{
		this_mon.enter();
		if (stopped || !started)
		{
			this_mon.exit();
			return;
		}
		int write_wait;
		stopped = true;
		write_wait = async_writes;
		this_mon.exit();
		break MISSING_BLOCK_LABEL_59;
		Exception exception;
		exception;
		this_mon.exit();
		throw exception;
		long log_time = SystemTime.getCurrentTime();
		for (int i = 0; i < write_wait; i++)
		{
			long now = SystemTime.getCurrentTime();
			if (now < log_time)
				log_time = now;
			else
			if (now - log_time > 1000L)
			{
				log_time = now;
				if (Logger.isEnabled())
					Logger.log(new LogEvent(disk_manager, LOGID, (new StringBuilder()).append("Waiting for writes to complete - ").append(write_wait - i).append(" remaining").toString()));
			}
			async_write_sem.reserve();
		}

		return;
	}

	public boolean isChecking()
	{
		return complete_recheck_in_progress;
	}

	public boolean zeroFile(DiskManagerFileInfoImpl file, long length)
		throws DiskManagerException
	{