pepeerstatsimpl.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:   PEPeerStatsImpl.java

package org.gudy.azureus2.core3.peer.impl;

import org.gudy.azureus2.core3.peer.PEPeer;
import org.gudy.azureus2.core3.peer.PEPeerStats;
import org.gudy.azureus2.core3.util.Average;
import org.gudy.azureus2.core3.util.SystemTime;

public class PEPeerStatsImpl
	implements PEPeerStats
{

	private PEPeer owner;
	private long total_data_bytes_received;
	private long total_protocol_bytes_received;
	private final Average data_receive_speed = Average.getInstance(1000, 10);
	private final Average protocol_receive_speed = Average.getInstance(1000, 10);
	private long total_data_bytes_sent;
	private long total_protocol_bytes_sent;
	private final Average data_send_speed = Average.getInstance(1000, 5);
	private final Average protocol_send_speed = Average.getInstance(1000, 5);
	private final Average receive_speed_for_choking = Average.getInstance(1000, 20);
	private final Average estimated_download_speed = Average.getInstance(5000, 100);
	private final Average estimated_upload_speed = Average.getInstance(3000, 60);
	private long total_bytes_discarded;
	private long total_bytes_downloaded;
	private long disk_read_bytes;
	private int disk_read_count;
	private int disk_aggregated_read_count;
	private long last_new_piece_time;

	public PEPeerStatsImpl(PEPeer _owner)
	{
		total_data_bytes_received = 0L;
		total_protocol_bytes_received = 0L;
		total_data_bytes_sent = 0L;
		total_protocol_bytes_sent = 0L;
		total_bytes_discarded = 0L;
		total_bytes_downloaded = 0L;
		disk_read_bytes = 0L;
		disk_read_count = 0;
		disk_aggregated_read_count = 0;
		owner = _owner;
	}

	public PEPeer getPeer()
	{
		return owner;
	}

	public void setPeer(PEPeer peer)
	{
		owner = peer;
	}

	public void dataBytesSent(int num_bytes)
	{
		total_data_bytes_sent += num_bytes;
		data_send_speed.addValue(num_bytes);
	}

	public void protocolBytesSent(int num_bytes)
	{
		total_protocol_bytes_sent += num_bytes;
		protocol_send_speed.addValue(num_bytes);
	}

	public void dataBytesReceived(int num_bytes)
	{
		total_data_bytes_received += num_bytes;
		data_receive_speed.addValue(num_bytes);
		receive_speed_for_choking.addValue(num_bytes);
	}

	public void protocolBytesReceived(int num_bytes)
	{
		total_protocol_bytes_received += num_bytes;
		protocol_receive_speed.addValue(num_bytes);
	}

	public void bytesDiscarded(int num_bytes)
	{
		total_bytes_discarded += num_bytes;
	}

	public void hasNewPiece(int piece_size)
	{
		total_bytes_downloaded += piece_size;
		if (owner.getTimeSinceConnectionEstablished() > 5000L)
		{
			estimated_download_speed.addValue(piece_size);
			last_new_piece_time = SystemTime.getCurrentTime();
		}
	}

	public long getEstimatedSecondsToCompletion()
	{
		long remaining = owner.getBytesRemaining();
		if (remaining == 0L)
			return 0L;
		long download_rate = estimated_download_speed.getAverage();
		long our_send_rate = getDataSendRate();
		if (download_rate < our_send_rate)
			download_rate = our_send_rate;
		if (download_rate == 0L)
			return 0x7fffffffffffffffL;
		if (last_new_piece_time > 0L)
		{
			long elapsed_secs = (SystemTime.getCurrentTime() - last_new_piece_time) / 1000L;
			remaining -= elapsed_secs * download_rate;
		}
		long secs_remaining = remaining / download_rate;
		if (secs_remaining <= 0L)
			secs_remaining = 1L;
		return secs_remaining;
	}

	public void statisticalSentPiece(int piece_size)
	{
		estimated_upload_speed.addValue(piece_size);
	}

	public long getDataReceiveRate()
	{
		return data_receive_speed.getAverage();
	}

	public long getProtocolReceiveRate()
	{
		return protocol_receive_speed.getAverage();
	}

	public long getDataSendRate()
	{
		return data_send_speed.getAverage();
	}

	public long getProtocolSendRate()
	{
		return protocol_send_speed.getAverage();
	}

	public long getSmoothDataReceiveRate()
	{
		return receive_speed_for_choking.getAverage();
	}

	public long getTotalBytesDiscarded()
	{
		return total_bytes_discarded;
	}

	public long getTotalBytesDownloadedByPeer()
	{
		return total_bytes_downloaded;
	}

	public long getEstimatedDownloadRateOfPeer()
	{
		return estimated_download_speed.getAverage();
	}

	public long getEstimatedUploadRateOfPeer()
	{
		return estimated_upload_speed.getAverage();
	}

	public long getTotalDataBytesReceived()
	{
		return total_data_bytes_received;
	}

	public long getTotalProtocolBytesReceived()
	{
		return total_protocol_bytes_received;
	}

	public long getTotalDataBytesSent()
	{
		return total_data_bytes_sent;
	}

	public long getTotalProtocolBytesSent()
	{
		return total_protocol_bytes_sent;
	}

	public void diskReadComplete(long bytes)
	{
		disk_read_bytes += bytes;
		disk_read_count++;
		if (bytes > 0L)
			disk_aggregated_read_count++;
	}

	public int getTotalDiskReadCount()
	{
		return disk_read_count;
	}

	public int getAggregatedDiskReadCount()
	{
		return disk_aggregated_read_count;
	}

	public long getTotalDiskReadBytes()
	{
		return disk_read_bytes;
	}

	public void setUploadRateLimitBytesPerSecond(int bytes)
	{
		owner.setUploadRateLimitBytesPerSecond(bytes);
	}

	public void setDownloadRateLimitBytesPerSecond(int bytes)
	{
		owner.setDownloadRateLimitBytesPerSecond(bytes);
	}

	public int getUploadRateLimitBytesPerSecond()
	{
		return owner.getUploadRateLimitBytesPerSecond();
	}

	public int getDownloadRateLimitBytesPerSecond()
	{
		return owner.getDownloadRateLimitBytesPerSecond();
	}
}