peerimpl.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:   PeerImpl.java

package org.gudy.azureus2.pluginsimpl.local.peers;

import com.aelitis.azureus.core.peermanager.piecepicker.util.BitFlags;
import java.util.HashMap;
import java.util.List;
import org.gudy.azureus2.core3.logging.LogRelation;
import org.gudy.azureus2.core3.peer.PEPeer;
import org.gudy.azureus2.core3.peer.PEPeerListener;
import org.gudy.azureus2.core3.util.AEMonitor;
import org.gudy.azureus2.core3.util.Debug;
import org.gudy.azureus2.plugins.messaging.Message;
import org.gudy.azureus2.plugins.network.Connection;
import org.gudy.azureus2.plugins.peers.*;
import org.gudy.azureus2.pluginsimpl.local.messaging.MessageAdapter;

// Referenced classes of package org.gudy.azureus2.pluginsimpl.local.peers:
//			PeerForeignDelegate, PeerManagerImpl, PeerStatsImpl

public class PeerImpl extends LogRelation
	implements Peer
{

	protected PeerManagerImpl manager;
	protected PEPeer delegate;
	protected AEMonitor this_mon;
	private HashMap peer_listeners;

	protected PeerImpl(PEPeer _delegate)
	{
		this_mon = new AEMonitor("Peer");
		delegate = _delegate;
		manager = PeerManagerImpl.getPeerManager(delegate.getManager());
	}

	public PeerManager getManager()
	{
		return manager;
	}

	protected PEPeer getDelegate()
	{
		return delegate;
	}

	public Connection getConnection()
	{
		return delegate.getPluginConnection();
	}

	public boolean supportsMessaging()
	{
		return delegate.supportsMessaging();
	}

	public Message[] getSupportedMessages()
	{
		com.aelitis.azureus.core.peermanager.messaging.Message core_msgs[] = delegate.getSupportedMessages();
		Message plug_msgs[] = new Message[core_msgs.length];
		for (int i = 0; i < core_msgs.length; i++)
			plug_msgs[i] = new MessageAdapter(core_msgs[i]);

		return plug_msgs;
	}

	public int getState()
	{
		int state = delegate.getPeerState();
		switch (state)
		{
		case 10: // '\n'
			return 10;

		case 50: // '2'
			return 50;

		case 20: // '\024'
			return 20;

		case 30: // '\036'
			return 30;
		}
		return -1;
	}

	public byte[] getId()
	{
		byte id[] = delegate.getId();
		if (id == null)
		{
			return null;
		} else
		{
			byte copy[] = new byte[id.length];
			System.arraycopy(id, 0, copy, 0, copy.length);
			return copy;
		}
	}

	public String getIp()
	{
		return delegate.getIp();
	}

	public int getPort()
	{
		return delegate.getPort();
	}

	public int getTCPListenPort()
	{
		return delegate.getTCPListenPort();
	}

	public int getUDPListenPort()
	{
		return delegate.getUDPListenPort();
	}

	public int getUDPNonDataListenPort()
	{
		return delegate.getUDPNonDataListenPort();
	}

	public final boolean[] getAvailable()
	{
		return delegate.getAvailable().flags;
	}

	public boolean isPieceAvailable(int pieceNumber)
	{
		return delegate.isPieceAvailable(pieceNumber);
	}

	public boolean isTransferAvailable()
	{
		return delegate.transferAvailable();
	}

	public boolean isDownloadPossible()
	{
		return delegate.isDownloadPossible();
	}

	public boolean isChoked()
	{
		return delegate.isChokingMe();
	}

	public boolean isChoking()
	{
		return delegate.isChokedByMe();
	}

	public boolean isInterested()
	{
		return delegate.isInteresting();
	}

	public boolean isInteresting()
	{
		return delegate.isInterested();
	}

	public boolean isSeed()
	{
		return delegate.isSeed();
	}

	public boolean isSnubbed()
	{
		return delegate.isSnubbed();
	}

	public long getSnubbedTime()
	{
		return delegate.getSnubbedTime();
	}

	public void setSnubbed(boolean b)
	{
		delegate.setSnubbed(b);
	}

	public PeerStats getStats()
	{
		return new PeerStatsImpl(manager, this, delegate.getStats());
	}

	public boolean isIncoming()
	{
		return delegate.isIncoming();
	}

	public int getPercentDone()
	{
		return delegate.getPercentDoneInThousandNotation();
	}

	public int getPercentDoneInThousandNotation()
	{
		return delegate.getPercentDoneInThousandNotation();
	}

	public String getClient()
	{
		return delegate.getClient();
	}

	public boolean isOptimisticUnchoke()
	{
		return delegate.isOptimisticUnchoke();
	}

	public void setOptimisticUnchoke(boolean is_optimistic)
	{
		delegate.setOptimisticUnchoke(is_optimistic);
	}

	public void initialize()
	{
		throw new RuntimeException("not supported");
	}

	public List getExpiredRequests()
	{
		throw new RuntimeException("not supported");
	}

	public List getRequests()
	{
		throw new RuntimeException("not supported");
	}

	public int getNumberOfRequests()
	{
		throw new RuntimeException("not supported");
	}

	public int getMaximumNumberOfRequests()
	{
		throw new RuntimeException("not supported");
	}

	public int[] getPriorityOffsets()
	{
		throw new RuntimeException("not supported");
	}

	public boolean requestAllocationStarts(int base_priorities[])
	{
		throw new RuntimeException("not supported");
	}

	public void requestAllocationComplete()
	{
		throw new RuntimeException("not supported");
	}

	public void cancelRequest(PeerReadRequest request)
	{
		throw new RuntimeException("not supported");
	}

	public boolean addRequest(PeerReadRequest request)
	{
		throw new RuntimeException("not supported");
	}

	public void close(String reason, boolean closedOnError, boolean attemptReconnect)
	{
		manager.removePeer(this, reason);
	}

	public int readBytes(int max)
	{
		throw new RuntimeException("not supported");
	}

	public int writeBytes(int max)
	{
		throw new RuntimeException("not supported");
	}

	protected void closed()
	{
		if (delegate instanceof PeerForeignDelegate)
			((PeerForeignDelegate)delegate).stop();
	}

	public int getPercentDoneOfCurrentIncomingRequest()
	{
		return delegate.getPercentDoneOfCurrentIncomingRequest();
	}

	public int getPercentDoneOfCurrentOutgoingRequest()
	{
		return delegate.getPercentDoneOfCurrentOutgoingRequest();
	}

	public void addListener(final PeerListener l)
	{
		PEPeerListener core_listener = new PEPeerListener() {

			final PeerListener val$l;
			final PeerImpl this$0;

			public void stateChanged(PEPeer peer, int new_state)
			{
				try
				{
					l.stateChanged(new_state);
				}
				catch (Throwable e)
				{
					Debug.printStackTrace(e);
				}
			}

			public void sentBadChunk(PEPeer peer, int piece_num, int total_bad_chunks)
			{
				try
				{
					l.sentBadChunk(piece_num, total_bad_chunks);
				}
				catch (Throwable e)
				{
					Debug.printStackTrace(e);
				}
			}

			public void addAvailability(PEPeer pepeer, BitFlags bitflags)
			{
			}

			public void removeAvailability(PEPeer pepeer, BitFlags bitflags)
			{
			}

			
			{
				this$0 = PeerImpl.this;
				l = peerlistener;
				super();
			}
		};
		delegate.addListener(core_listener);
		if (peer_listeners == null)
			peer_listeners = new HashMap();
		peer_listeners.put(l, core_listener);
	}

	public void removeListener(PeerListener l)
	{
		if (peer_listeners != null)
		{
			PEPeerListener core_listener = (PEPeerListener)peer_listeners.remove(l);
			if (core_listener != null)
				delegate.removeListener(core_listener);
		}
	}

	public void addListener(final PeerListener2 l)
	{
		PEPeerListener core_listener = new PEPeerListener() {

			final PeerListener2 val$l;
			final PeerImpl this$0;

			public void stateChanged(PEPeer peer, int new_state)
			{
				fireEvent(1, new Integer(new_state));
			}

			public void sentBadChunk(PEPeer peer, int piece_num, int total_bad_chunks)
			{
				fireEvent(2, new Integer[] {
					new Integer(piece_num), new Integer(total_bad_chunks)
				});
			}

			public void addAvailability(PEPeer peer, BitFlags peerHavePieces)
			{
				fireEvent(3, peerHavePieces.flags);
			}

			public void removeAvailability(PEPeer peer, BitFlags peerHavePieces)
			{
				fireEvent(4, peerHavePieces.flags);
			}

			protected void fireEvent(final int type, final Object data)
			{
				try
				{
					l.eventOccurred(new PeerEvent() {

						final int val$type;
						final Object val$data;
						final 2 this$1;

						public int getType()
						{
							return type;
						}

						public Object getData()
						{
							return data;
						}

					
					{
						this$1 = 2.this;
						type = i;
						data = obj;
						super();
					}
					});
				}
				catch (Throwable e)
				{
					Debug.printStackTrace(e);
				}
			}

			
			{
				this$0 = PeerImpl.this;
				l = peerlistener2;
				super();
			}
		};
		delegate.addListener(core_listener);
		if (peer_listeners == null)
			peer_listeners = new HashMap();
		peer_listeners.put(l, core_listener);
	}

	public void removeListener(PeerListener2 l)
	{
		if (peer_listeners != null)
		{
			PEPeerListener core_listener = (PEPeerListener)peer_listeners.remove(l);
			if (core_listener != null)
				delegate.removeListener(core_listener);
		}
	}

	public boolean isPriorityConnection()
	{
		return delegate.isPriorityConnection();
	}

	public void setPriorityConnection(boolean is_priority)
	{
		delegate.setPriorityConnection(is_priority);
	}

	public void setUserData(Object key, Object value)
	{
		delegate.setUserData(key, value);
	}

	public Object getUserData(Object key)
	{
		return delegate.getUserData(key);
	}

	public boolean equals(Object other)
	{
		if (other instanceof PeerImpl)
			return delegate == ((PeerImpl)other).delegate;
		else
			return false;
	}

	public int hashCode()
	{
		return delegate.hashCode();
	}

	public PEPeer getPEPeer()
	{
		return delegate;
	}

	public String getRelationText()
	{
		return propogatedRelationText(delegate);
	}

	public Object[] getQueryableInterfaces()
	{
		return (new Object[] {
			delegate
		});
	}

	public byte[] getHandshakeReservedBytes()
	{
		return delegate.getHandshakeReservedBytes();
	}
}