peerforeigndelegate.java

java 文件下载器。可自定义

	{
	}

	public boolean isTCP()
	{
		return true;
	}

	public PEPeerStats getStats()
	{
		return ((PeerStatsImpl)foreign.getStats()).getDelegate();
	}

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

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

	public long getBytesRemaining()
	{
		int rem_pm;
		rem_pm = 1000 - getPercentDoneInThousandNotation();
		if (rem_pm == 0)
			return 0L;
		Torrent t = manager.getDownload().getTorrent();
		if (t == null)
			return 0x7fffffffffffffffL;
		return (t.getSize() * (long)rem_pm) / 1000L;
		Throwable e;
		e;
		return 0x7fffffffffffffffL;
	}

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

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

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

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

	public int getUniqueAnnounce()
	{
		return -1;
	}

	public int getUploadHint()
	{
		return 0;
	}

	public void setUniqueAnnounce(int i)
	{
	}

	public void setUploadHint(int i)
	{
	}

	public boolean isStalledPendingLoad()
	{
		return false;
	}

	public void addListener(final PEPeerListener l)
	{
		final PEPeer self = this;
		PeerListener2 core_listener = new PeerListener2() {

			final PEPeerListener val$l;
			final PEPeer val$self;
			final PeerForeignDelegate this$0;

			public void eventOccurred(PeerEvent event)
			{
				Object data = event.getData();
				switch (event.getType())
				{
				case 1: // '\001'
					l.stateChanged(self, ((Integer)data).intValue());
					break;

				case 2: // '\002'
					Integer d[] = (Integer[])(Integer[])data;
					l.sentBadChunk(self, d[0].intValue(), d[1].intValue());
					break;

				case 3: // '\003'
					l.addAvailability(self, new BitFlags((boolean[])(boolean[])data));
					break;

				case 4: // '\004'
					l.removeAvailability(self, new BitFlags((boolean[])(boolean[])data));
					break;
				}
			}

			
			{
				this$0 = PeerForeignDelegate.this;
				l = pepeerlistener;
				self = pepeer;
				super();
			}
		};
		foreign.addListener(core_listener);
		if (peer_listeners == null)
			peer_listeners = new HashMap();
		peer_listeners.put(l, core_listener);
	}

	public void removeListener(PEPeerListener l)
	{
		if (peer_listeners != null)
		{
			Object core_listener = peer_listeners.remove(l);
			if (core_listener != null)
				if (core_listener instanceof PeerListener)
					foreign.removeListener((PeerListener)core_listener);
				else
					foreign.removeListener((PeerListener2)core_listener);
		}
	}

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

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

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

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

	public int getMessagingMode()
	{
		return 4;
	}

	public String getEncryption()
	{
		return "";
	}

	public Message[] getSupportedMessages()
	{
		org.gudy.azureus2.plugins.messaging.Message plug_msgs[] = foreign.getSupportedMessages();
		Message core_msgs[] = new Message[plug_msgs.length];
		for (int i = 0; i < plug_msgs.length; i++)
			core_msgs[i] = new MessageAdapter(plug_msgs[i]);

		return core_msgs;
	}

	public Object getData(String key)
	{
		return getUserData(key);
	}

	public void setData(String key, Object value)
	{
		setUserData(key, value);
	}

	public Object getUserData(Object key)
	{
		Object obj;
		this_mon.enter();
		if (data != null)
			break MISSING_BLOCK_LABEL_25;
		obj = null;
		this_mon.exit();
		return obj;
		obj = data.get(key);
		this_mon.exit();
		return obj;
		Exception exception;
		exception;
		this_mon.exit();
		throw exception;
	}

	public void setUserData(Object key, Object value)
	{
		this_mon.enter();
		if (data == null)
			data = new LightHashMap();
		if (value == null)
		{
			if (data.containsKey(key))
			{
				data.remove(key);
				if (data.size() == 0)
					data = null;
			}
		} else
		{
			data.put(key, value);
		}
		this_mon.exit();
		break MISSING_BLOCK_LABEL_105;
		Exception exception;
		exception;
		this_mon.exit();
		throw exception;
	}

	public boolean equals(Object other)
	{
		if (other instanceof PeerForeignDelegate)
			return foreign.equals(((PeerForeignDelegate)other).foreign);
		else
			return false;
	}

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

	public int getReservedPieceNumber()
	{
		return reserved_piece;
	}

	public void setReservedPieceNumber(int pieceNumber)
	{
		reserved_piece = pieceNumber;
	}

	public int[] getIncomingRequestedPieceNumbers()
	{
		return new int[0];
	}

	public int getIncomingRequestCount()
	{
		return 0;
	}

	public int getOutgoingRequestCount()
	{
		return foreign.getRequests().size();
	}

	public int[] getOutgoingRequestedPieceNumbers()
	{
		List l = foreign.getRequests();
		int res[] = new int[l.size()];
		for (int i = 0; i < l.size(); i++)
			res[i] = ((PeerReadRequest)l.get(i)).getPieceNumber();

		return res;
	}

	public int getOutboundDataQueueSize()
	{
		return getOutgoingRequestCount() * 16384;
	}

	public int getLastPiece()
	{
		return _lastPiece;
	}

	public void setLastPiece(int pieceNumber)
	{
		_lastPiece = pieceNumber;
	}

	public void checkInterested()
	{
	}

	public boolean isAvailabilityAdded()
	{
		return false;
	}

	public void clearAvailabilityAdded()
	{
	}

	public PEPeerTransport reconnect(boolean tryUDP)
	{
		return null;
	}

	public boolean isSafeForReconnect()
	{
		return false;
	}

	public void setUploadRateLimitBytesPerSecond(int bytes)
	{
		network_connection.setUploadLimit(bytes);
	}

	public void setDownloadRateLimitBytesPerSecond(int bytes)
	{
		network_connection.setDownloadLimit(bytes);
	}

	public int getUploadRateLimitBytesPerSecond()
	{
		return network_connection.getUploadLimit();
	}

	public int getDownloadRateLimitBytesPerSecond()
	{
		return network_connection.getDownloadLimit();
	}

	public void addRateLimiter(LimitedRateGroup limiter, boolean upload)
	{
		network_connection.addRateLimiter(limiter, upload);
	}

	public void removeRateLimiter(LimitedRateGroup limiter, boolean upload)
	{
		network_connection.removeRateLimiter(limiter, upload);
	}

	public void setHaveAggregationEnabled(boolean flag)
	{
	}

	public void setPriorityConnection(boolean is_priority)
	{
		priority_connection = is_priority;
	}

	public boolean isPriorityConnection()
	{
		return priority_connection;
	}

	public void generateEvidence(IndentWriter writer)
	{
		writer.println((new StringBuilder()).append("delegate: ip=").append(getIp()).append(",tcp=").append(getTCPListenPort()).append(",udp=").append(getUDPListenPort()).append(",state=").append(foreign.getState()).append(",foreign=").append(foreign).toString());
	}

	public String getClientNameFromExtensionHandshake()
	{
		return null;
	}

	public String getClientNameFromPeerID()
	{
		return null;
	}
}