displayformatters.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:   DisplayFormatters.java

package org.gudy.azureus2.core3.util;

import java.io.PrintStream;
import java.text.*;
import java.util.*;
import org.gudy.azureus2.core3.config.*;
import org.gudy.azureus2.core3.disk.DiskManager;
import org.gudy.azureus2.core3.download.DownloadManager;
import org.gudy.azureus2.core3.download.DownloadManagerStats;
import org.gudy.azureus2.core3.internat.MessageText;
import org.gudy.azureus2.core3.peer.PEPeerManager;
import org.gudy.azureus2.core3.torrent.TOTorrent;

// Referenced classes of package org.gudy.azureus2.core3.util:
//			TimeFormatter

public class DisplayFormatters
{

	private static final boolean ROUND_NO = true;
	private static final boolean TRUNCZEROS_NO = false;
	private static final boolean TRUNCZEROS_YES = true;
	public static final int UNIT_B = 0;
	public static final int UNIT_KB = 1;
	public static final int UNIT_MB = 2;
	public static final int UNIT_GB = 3;
	public static final int UNIT_TB = 4;
	private static final int UNITS_PRECISION[] = {
		0, 1, 2, 2, 3
	};
	private static final NumberFormat cached_number_formats[] = new NumberFormat[20];
	private static NumberFormat percentage_format;
	private static String units[];
	private static String units_bits[];
	private static String units_rate[];
	private static int unitsStopAt = 4;
	private static String units_base10[];
	private static String per_sec;
	private static boolean use_si_units = COConfigurationManager.getBooleanParameter("config.style.useSIUnits");
	private static boolean use_units_rate_bits = COConfigurationManager.getBooleanParameter("config.style.useUnitsRateBits");
	private static boolean not_use_GB_TB;
	private static int message_text_state = 0;
	private static boolean separate_prot_data_stats;
	private static boolean data_stats_only;
	private static char decimalSeparator;
	private static String PeerManager_status_finished;
	private static String PeerManager_status_finishedin;
	private static String Formats_units_alot;
	private static String discarded;
	private static String ManagerItem_waiting;
	private static String ManagerItem_initializing;
	private static String ManagerItem_allocating;
	private static String ManagerItem_checking;
	private static String ManagerItem_finishing;
	private static String ManagerItem_ready;
	private static String ManagerItem_downloading;
	private static String ManagerItem_seeding;
	private static String ManagerItem_superseeding;
	private static String ManagerItem_stopping;
	private static String ManagerItem_stopped;
	private static String ManagerItem_paused;
	private static String ManagerItem_queued;
	private static String ManagerItem_error;
	private static String ManagerItem_forced;
	private static String yes;
	private static String no;

	public DisplayFormatters()
	{
	}

	public static void setUnits()
	{
		units = new String[unitsStopAt + 1];
		units_bits = new String[unitsStopAt + 1];
		units_rate = new String[unitsStopAt + 1];
		if (use_si_units)
			switch (unitsStopAt)
			{
			case 4: // '\004'
				units[4] = getUnit("TiB");
				units_bits[4] = getUnit("Tibit");
				units_rate[4] = use_units_rate_bits ? getUnit("Tibit") : getUnit("TiB");
				// fall through

			case 3: // '\003'
				units[3] = getUnit("GiB");
				units_bits[3] = getUnit("Gibit");
				units_rate[3] = use_units_rate_bits ? getUnit("Gibit") : getUnit("GiB");
				// fall through

			case 2: // '\002'
				units[2] = getUnit("MiB");
				units_bits[2] = getUnit("Mibit");
				units_rate[2] = use_units_rate_bits ? getUnit("Mibit") : getUnit("MiB");
				// fall through

			case 1: // '\001'
				units[1] = getUnit("KiB");
				units_bits[1] = getUnit("Kibit");
				units_rate[1] = use_units_rate_bits ? getUnit("Kibit") : getUnit("KiB");
				// fall through

			case 0: // '\0'
				units[0] = getUnit("B");
				units_bits[0] = getUnit("bit");
				units_rate[0] = use_units_rate_bits ? getUnit("bit") : getUnit("B");
				break;
			}
		else
			switch (unitsStopAt)
			{
			case 4: // '\004'
				units[4] = getUnit("TB");
				units_bits[4] = getUnit("Tbit");
				units_rate[4] = use_units_rate_bits ? getUnit("Tbit") : getUnit("TB");
				// fall through

			case 3: // '\003'
				units[3] = getUnit("GB");
				units_bits[3] = getUnit("Gbit");
				units_rate[3] = use_units_rate_bits ? getUnit("Gbit") : getUnit("GB");
				// fall through

			case 2: // '\002'
				units[2] = getUnit("MB");
				units_bits[2] = getUnit("Mbit");
				units_rate[2] = use_units_rate_bits ? getUnit("Mbit") : getUnit("MB");
				// fall through

			case 1: // '\001'
				units[1] = getUnit("kB");
				units_bits[1] = getUnit("kbit");
				units_rate[1] = use_units_rate_bits ? getUnit("kbit") : getUnit("kB");
				// fall through

			case 0: // '\0'
				units[0] = getUnit("B");
				units_bits[0] = getUnit("bit");
				units_rate[0] = use_units_rate_bits ? getUnit("bit") : getUnit("B");
				break;
			}
		per_sec = getResourceString("Formats.units.persec", "/s");
		units_base10 = (new String[] {
			getUnit("B"), getUnit("KB"), getUnit("MB"), getUnit("GB"), getUnit("TB")
		});
		for (int i = 0; i <= unitsStopAt; i++)
		{
			units[i] = units[i];
			units_rate[i] = (new StringBuilder()).append(units_rate[i]).append(per_sec).toString();
		}

		Arrays.fill(cached_number_formats, null);
		percentage_format = NumberFormat.getPercentInstance();
		percentage_format.setMinimumFractionDigits(1);
		percentage_format.setMaximumFractionDigits(1);
		decimalSeparator = (new DecimalFormatSymbols()).getDecimalSeparator();
	}

	private static String getUnit(String key)
	{
		String res = (new StringBuilder()).append(" ").append(getResourceString((new StringBuilder()).append("Formats.units.").append(key).toString(), key)).toString();
		return res;
	}

	public static void loadMessages()
	{
		PeerManager_status_finished = getResourceString("PeerManager.status.finished", "Finished");
		PeerManager_status_finishedin = getResourceString("PeerManager.status.finishedin", "Finished in");
		Formats_units_alot = getResourceString("Formats.units.alot", "A lot");
		discarded = getResourceString("discarded", "discarded");
		ManagerItem_waiting = getResourceString("ManagerItem.waiting", "waiting");
		ManagerItem_initializing = getResourceString("ManagerItem.initializing", "initializing");
		ManagerItem_allocating = getResourceString("ManagerItem.allocating", "allocating");
		ManagerItem_checking = getResourceString("ManagerItem.checking", "checking");
		ManagerItem_finishing = getResourceString("ManagerItem.finishing", "finishing");
		ManagerItem_ready = getResourceString("ManagerItem.ready", "ready");
		ManagerItem_downloading = getResourceString("ManagerItem.downloading", "downloading");
		ManagerItem_seeding = getResourceString("ManagerItem.seeding", "seeding");
		ManagerItem_superseeding = getResourceString("ManagerItem.superseeding", "superseeding");
		ManagerItem_stopping = getResourceString("ManagerItem.stopping", "stopping");
		ManagerItem_stopped = getResourceString("ManagerItem.stopped", "stopped");
		ManagerItem_paused = getResourceString("ManagerItem.paused", "paused");
		ManagerItem_queued = getResourceString("ManagerItem.queued", "queued");
		ManagerItem_error = getResourceString("ManagerItem.error", "error");
		ManagerItem_forced = getResourceString("ManagerItem.forced", "forced");
		yes = getResourceString("GeneralView.yes", "Yes");
		no = getResourceString("GeneralView.no", "No");
	}

	private static String getResourceString(String key, String def)
	{
		if (message_text_state == 0)
			try
			{
				org/gudy/azureus2/core3/internat/MessageText.getName();
				message_text_state = 1;
			}
			catch (Throwable e)
			{
				message_text_state = 2;
			}
		if (message_text_state == 1)
			return MessageText.getString(key);
		else
			return def;
	}

	public static String getYesNo(boolean b)
	{
		return b ? yes : no;
	}

	public static String getRateUnit(int unit_size)
	{
		return units_rate[unit_size].substring(1, units_rate[unit_size].length());
	}

	public static String getUnit(int unit_size)
	{
		return units[unit_size].substring(1, units[unit_size].length());
	}

	public static String getRateUnitBase10(int unit_size)
	{
		return (new StringBuilder()).append(units_base10[unit_size]).append(per_sec).toString();
	}

	public static String getUnitBase10(int unit_size)
	{
		return units_base10[unit_size];
	}

	public static String formatByteCountToKiBEtc(int n)
	{
		return formatByteCountToKiBEtc(n);
	}

	public static String formatByteCountToKiBEtc(long n)
	{
		return formatByteCountToKiBEtc(n, false, false);
	}

	public static String formatByteCountToKiBEtc(long n, boolean bTruncateZeros)
	{
		return formatByteCountToKiBEtc(n, false, bTruncateZeros);
	}

	public static String formatByteCountToKiBEtc(long n, boolean rate, boolean bTruncateZeros)
	{
		return formatByteCountToKiBEtc(n, rate, bTruncateZeros, -1);
	}

	public static String formatByteCountToKiBEtc(long n, boolean rate, boolean bTruncateZeros, int precision)
	{
		double dbl = !rate || !use_units_rate_bits ? n : n * 8L;
		int unitIndex;
		for (unitIndex = 0; dbl >= 1024D && unitIndex < unitsStopAt; unitIndex++)
			dbl /= 1024D;

		if (precision < 0)
			precision = UNITS_PRECISION[unitIndex];
		return (new StringBuilder()).append(formatDecimal(dbl, precision, bTruncateZeros, rate)).append(rate ? units_rate[unitIndex] : units[unitIndex]).toString();
	}

	public static boolean isDataProtSeparate()
	{
		return separate_prot_data_stats;
	}

	public static String formatDataProtByteCountToKiBEtc(long data, long prot)
	{
		if (separate_prot_data_stats)
		{
			if (data == 0L && prot == 0L)
				return formatByteCountToKiBEtc(0);
			if (data == 0L)
				return (new StringBuilder()).append("(").append(formatByteCountToKiBEtc(prot)).append(")").toString();
			if (prot == 0L)
				return formatByteCountToKiBEtc(data);
			else
				return (new StringBuilder()).append(formatByteCountToKiBEtc(data)).append(" (").append(formatByteCountToKiBEtc(prot)).append(")").toString();
		}
		if (data_stats_only)
			return formatByteCountToKiBEtc(data);
		else
			return formatByteCountToKiBEtc(prot + data);
	}

	public static String formatDataProtByteCountToKiBEtcPerSec(long data, long prot)
	{
		if (separate_prot_data_stats)
		{
			if (data == 0L && prot == 0L)
				return formatByteCountToKiBEtcPerSec(0L);
			if (data == 0L)
				return (new StringBuilder()).append("(").append(formatByteCountToKiBEtcPerSec(prot)).append(")").toString();
			if (prot == 0L)
				return formatByteCountToKiBEtcPerSec(data);
			else
				return (new StringBuilder()).append(formatByteCountToKiBEtcPerSec(data)).append(" (").append(formatByteCountToKiBEtcPerSec(prot)).append(")").toString();
		}
		if (data_stats_only)
			return formatByteCountToKiBEtcPerSec(data);
		else
			return formatByteCountToKiBEtcPerSec(prot + data);
	}

	public static String formatByteCountToKiBEtcPerSec(long n)
	{
		return formatByteCountToKiBEtc(n, true, false);
	}

	public static String formatByteCountToKiBEtcPerSec(long n, boolean bTruncateZeros)
	{
		return formatByteCountToKiBEtc(n, true, bTruncateZeros);
	}

	public static String formatByteCountToBase10KBEtc(long n)
	{
		if (n < 1000L)
			return (new StringBuilder()).append(n).append(units_base10[0]).toString();
		if (n < 0xf4240L)
			return (new StringBuilder()).append(n / 1000L).append(".").append((n % 1000L) / 100L).append(units_base10[1]).toString();
		if (n < 0x3b9aca00L || not_use_GB_TB)
			return (new StringBuilder()).append(n / 0xf4240L).append(".").append((n % 0xf4240L) / 0x186a0L).append(units_base10[2]).toString();
		if (n < 0xe8d4a51000L)
			return (new StringBuilder()).append(n / 0x3b9aca00L).append(".").append((n % 0x3b9aca00L) / 0x5f5e100L).append(units_base10[3]).toString();
		if (n < 0x38d7ea4c68000L)
			return (new StringBuilder()).append(n / 0xe8d4a51000L).append(".").append((n % 0xe8d4a51000L) / 0x174876e800L).append(units_base10[4]).toString();
		else
			return Formats_units_alot;
	}

	public static String formatByteCountToBase10KBEtcPerSec(long n)
	{
		return (new StringBuilder()).append(formatByteCountToBase10KBEtc(n)).append(per_sec).toString();
	}

	public static String formatByteCountToBitsPerSec(long n)
	{
		return formatBitCountToKiBEtcLocalImpl(n, true, true, -1, true);
	}

	public static String formatBitCountToKiBEtcLocalImpl(long n, boolean rate, boolean bTruncateZeros, int precision, boolean useBits)
	{
		double dbl = !rate || !useBits ? n : n * 8L;
		int unitIndex;
		for (unitIndex = 0; dbl >= 1024D && unitIndex < unitsStopAt; unitIndex++)
			dbl /= 1024D;

		if (precision < 0)
			precision = UNITS_PRECISION[unitIndex];
		return (new StringBuilder()).append(formatDecimal(dbl, precision, bTruncateZeros, rate)).append(units_bits[unitIndex]).append(rate ? per_sec : "").toString();
	}

	public static String formatETA(long eta)
	{
		if (eta == 0L)
			return PeerManager_status_finished;
		if (eta == -1L)
			return "";
		if (eta > 0L)
			return TimeFormatter.format(eta);
		else
			return (new StringBuilder()).append(PeerManager_status_finishedin).append(" ").append(TimeFormatter.format(eta * -1L)).toString();
	}

	public static String formatDownloaded(DownloadManagerStats stats)
	{
		long total_discarded = stats.getDiscarded();
		long total_received = stats.getTotalGoodDataBytesReceived();
		if (total_discarded == 0L)
			return formatByteCountToKiBEtc(total_received);
		else
			return (new StringBuilder()).append(formatByteCountToKiBEtc(total_received)).append(" ( ").append(formatByteCountToKiBEtc(total_discarded)).append(" ").append(discarded).append(" )").toString();
	}

	public static String formatHashFails(DownloadManager download_manager)
	{
		TOTorrent torrent = download_manager.getTorrent();
		if (torrent != null)
		{
			long bad = download_manager.getStats().getHashFailBytes();
			long count = bad / torrent.getPieceLength();
			String result = (new StringBuilder()).append(count).append(" ( ").append(formatByteCountToKiBEtc(bad)).append(" )").toString();
			return result;
		} else
		{
			return "";
		}
	}

	public static String formatDownloadStatus(DownloadManager manager)
	{
		int state = manager.getState();
		String tmp = "";
		switch (state)
		{
		case 75: // 'K'
			tmp = ManagerItem_queued;
			break;

		case 50: // '2'
			tmp = ManagerItem_downloading;
			break;

		case 60: // '<'
			DiskManager diskManager = manager.getDiskManager();
			if (diskManager != null && diskManager.getCompleteRecheckStatus() != -1)
			{
				int done = diskManager.getCompleteRecheckStatus();