pepeermanagerstatsimpl.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:   PEPeerManagerStatsImpl.java

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

import org.gudy.azureus2.core3.peer.*;
import org.gudy.azureus2.core3.peer.impl.control.PEPeerControlImpl;
import org.gudy.azureus2.core3.util.Average;
import org.gudy.azureus2.core3.util.SystemTime;

public class PEPeerManagerStatsImpl
	implements PEPeerManagerStats
{

	private PEPeerManagerAdapter adapter;
	private long total_data_bytes_received;
	private long total_protocol_bytes_received;
	private long total_data_bytes_sent;
	private long total_protocol_bytes_sent;
	private long totalDiscarded;
	private long hash_fail_bytes;
	private int last_data_received_seconds;
	private int last_data_sent_seconds;
	private final Average data_receive_speed = Average.getInstance(1000, 10);
	private final Average protocol_receive_speed = Average.getInstance(1000, 10);
	private final Average data_send_speed = Average.getInstance(1000, 10);
	private final Average protocol_send_speed = Average.getInstance(1000, 10);
	private final Average overallSpeed = Average.getInstance(5000, 100);

	public PEPeerManagerStatsImpl(PEPeerControlImpl _manager)
	{
		total_data_bytes_received = 0L;
		total_protocol_bytes_received = 0L;
		total_data_bytes_sent = 0L;
		total_protocol_bytes_sent = 0L;
		adapter = _manager.getAdapter();
	}

	public void discarded(PEPeer peer, int length)
	{
		totalDiscarded += length;
		adapter.discarded(peer, length);
	}

	public void hashFailed(int length)
	{
		hash_fail_bytes += length;
	}

	public long getTotalHashFailBytes()
	{
		return hash_fail_bytes;
	}

	public void dataBytesReceived(PEPeer peer, int length)
	{
		total_data_bytes_received += length;
		data_receive_speed.addValue(length);
		if (length > 0)
			last_data_received_seconds = (int)(SystemTime.getCurrentTime() / 1000L);
		adapter.dataBytesReceived(peer, length);
	}

	public void protocolBytesReceived(PEPeer peer, int length)
	{
		total_protocol_bytes_received += length;
		protocol_receive_speed.addValue(length);
		adapter.protocolBytesReceived(peer, length);
	}

	public void dataBytesSent(PEPeer peer, int length)
	{
		total_data_bytes_sent += length;
		data_send_speed.addValue(length);
		if (length > 0)
			last_data_sent_seconds = (int)(SystemTime.getCurrentTime() / 1000L);
		adapter.dataBytesSent(peer, length);
	}

	public void protocolBytesSent(PEPeer peer, int length)
	{
		total_protocol_bytes_sent += length;
		protocol_send_speed.addValue(length);
		adapter.protocolBytesSent(peer, length);
	}

	public void haveNewPiece(int pieceLength)
	{
		overallSpeed.addValue(pieceLength);
	}

	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 getTotalDiscarded()
	{
		return totalDiscarded;
	}

	public void setTotalDiscarded(long total)
	{
		totalDiscarded = total;
	}

	public long getTotalDataBytesSent()
	{
		return total_data_bytes_sent;
	}

	public long getTotalProtocolBytesSent()
	{
		return total_protocol_bytes_sent;
	}

	public long getTotalDataBytesReceived()
	{
		return total_data_bytes_received;
	}

	public long getTotalProtocolBytesReceived()
	{
		return total_protocol_bytes_received;
	}

	public long getTotalAverage()
	{
		return overallSpeed.getAverage() + getDataReceiveRate();
	}

	public int getTimeSinceLastDataReceivedInSeconds()
	{
		if (last_data_received_seconds == 0)
			return -1;
		int now = (int)(SystemTime.getCurrentTime() / 1000L);
		if (now < last_data_received_seconds)
			last_data_received_seconds = now;
		return now - last_data_received_seconds;
	}

	public int getTimeSinceLastDataSentInSeconds()
	{
		if (last_data_sent_seconds == 0)
			return -1;
		int now = (int)(SystemTime.getCurrentTime() / 1000L);
		if (now < last_data_sent_seconds)
			last_data_sent_seconds = now;
		return now - last_data_sent_seconds;
	}
}