Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.wicket.util.lang; import java.text.NumberFormat; import java.text.ParseException; import java.util.Locale; import java.util.regex.Matcher; import java.util.regex.Pattern; import org.apache.wicket.util.string.StringValue; import org.apache.wicket.util.string.StringValueConversionException; import org.apache.wicket.util.value.LongValue; /** * Represents an immutable byte count. These static factory methods allow easy construction of value * objects using either long values like bytes(2034) or megabytes(3): * <p> * <ul> * <li>Bytes.bytes(long) * <li>Bytes.kilobytes(long) * <li>Bytes.megabytes(long) * <li>Bytes.gigabytes(long) * <li>Bytes.terabytes(long) * </ul> * <p> * or double precision floating point values like megabytes(3.2): * <p> * <ul> * <li>Bytes.bytes(double) * <li>Bytes.kilobytes(double) * <li>Bytes.megabytes(double) * <li>Bytes.gigabytes(double) * <li>Bytes.terabytes(double) * </ul> * <p> * In the case of bytes(double), the value will be rounded off to the nearest integer byte count * using Math.round(). * <p> * The precise number of bytes in a Bytes object can be retrieved by calling bytes(). Approximate * values for different units can be retrieved as double precision values using these methods: * <p> * <ul> * <li>kilobytes() * <li>megabytes() * <li>gigabytes() * <li>terabytes() * </ul> * <p> * Also, value objects can be constructed from strings, optionally using a Locale with * valueOf(String) and valueOf(String,Locale). The string may contain a decimal or floating point * number followed by optional whitespace followed by a unit (nothing for bytes, K for kilobyte, M * for megabytes, G for gigabytes or T for terabytes) optionally followed by a B (for bytes). Any of * these letters can be any case. So, examples of permissible string values are: * <p> * <ul> * <li>37 (37 bytes) * <li>2.3K (2.3 kilobytes) * <li>2.5 kb (2.5 kilobytes) * <li>4k (4 kilobytes) * <li>35.2GB (35.2 gigabytes) * <li>1024M (1024 megabytes) * </ul> * <p> * Note that if the Locale was not US, the values might substitute "," for "." as that is the custom * in Euroland. * <p> * The toString() and toString(Locale) methods are smart enough to convert a given value object to * the most appropriate units for the given value. * * @author Jonathan Locke */ public final class Bytes extends LongValue { private static final long serialVersionUID = 1L; /** Pattern for string parsing. */ private static final Pattern valuePattern = Pattern.compile("([0-9]+([\\.,][0-9]+)?)\\s*(|K|M|G|T)B?", Pattern.CASE_INSENSITIVE); /** Maximum bytes value */ public static final Bytes MAX = bytes(Long.MAX_VALUE); /** * Private constructor forces use of static factory methods. * * @param bytes * Number of bytes */ private Bytes(final long bytes) { super(bytes); if (bytes < 0) { throw new IllegalArgumentException("'bytes' cannot be negative: " + bytes); } } /** * Instantiate immutable Bytes value object.. * * @param bytes * Value to convert * @return Input as Bytes */ public static Bytes bytes(final long bytes) { return new Bytes(bytes); } /** * Instantiate immutable Bytes value object.. * * @param kilobytes * Value to convert * @return Input as Bytes */ public static Bytes kilobytes(final long kilobytes) { return bytes(kilobytes * 1024); } /** * Instantiate immutable Bytes value object.. * * @param megabytes * Value to convert * @return Input as Bytes */ public static Bytes megabytes(final long megabytes) { return kilobytes(megabytes * 1024); } /** * Instantiate immutable Bytes value object.. * * @param gigabytes * Value to convert * @return Input as Bytes */ public static Bytes gigabytes(final long gigabytes) { return megabytes(gigabytes * 1024); } /** * Instantiate immutable Bytes value object.. * * @param terabytes * Value to convert * @return Input as Bytes */ public static Bytes terabytes(final long terabytes) { return gigabytes(terabytes * 1024); } /** * Instantiate immutable Bytes value object.. * * @param bytes * Value to convert * @return Input as Bytes */ public static Bytes bytes(final double bytes) { return bytes(Math.round(bytes)); } /** * Instantiate immutable Bytes value object.. * * @param kilobytes * Value to convert * @return Input as Bytes */ public static Bytes kilobytes(final double kilobytes) { return bytes(kilobytes * 1024.0); } /** * Instantiate immutable Bytes value object.. * * @param megabytes * Value to convert * @return Input as Bytes */ public static Bytes megabytes(final double megabytes) { return kilobytes(megabytes * 1024.0); } /** * Instantiate immutable Bytes value object.. * * @param gigabytes * Value to convert * @return Input as Bytes */ public static Bytes gigabytes(final double gigabytes) { return megabytes(gigabytes * 1024.0); } /** * Instantiate immutable Bytes value object.. * * @param terabytes * Value to convert * @return Input as Bytes */ public static Bytes terabytes(final double terabytes) { return gigabytes(terabytes * 1024.0); } /** * Gets the byte count represented by this value object. * * @return Byte count */ public final long bytes() { return value; } /** * Gets the byte count in kilobytes. * * @return The value in kilobytes */ public final double kilobytes() { return value / 1024.0; } /** * Gets the byte count in megabytes. * * @return The value in megabytes */ public final double megabytes() { return kilobytes() / 1024.0; } /** * Gets the byte count in gigabytes. * * @return The value in gigabytes */ public final double gigabytes() { return megabytes() / 1024.0; } /** * Gets the byte count in terabytes. * * @return The value in terabytes */ public final double terabytes() { return gigabytes() / 1024.0; } /** * Converts a string to a number of bytes. Strings consist of a floating point value followed by * K, M, G or T for kilobytes, megabytes, gigabytes or terabytes, respectively. The * abbreviations KB, MB, GB and TB are also accepted. Matching is case insensitive. * * @param string * The string to convert * @param locale * The Locale to be used for transformation * @return The Bytes value for the string * @throws StringValueConversionException */ public static Bytes valueOf(final String string, final Locale locale) throws StringValueConversionException { final Matcher matcher = valuePattern.matcher(string); // Valid input? if (matcher.matches()) { try { // Get double precision value final double value = NumberFormat.getNumberInstance(locale).parse(matcher.group(1)).doubleValue(); // Get units specified final String units = matcher.group(3); if (units.equalsIgnoreCase("")) { return bytes(value); } else if (units.equalsIgnoreCase("K")) { return kilobytes(value); } else if (units.equalsIgnoreCase("M")) { return megabytes(value); } else if (units.equalsIgnoreCase("G")) { return gigabytes(value); } else if (units.equalsIgnoreCase("T")) { return terabytes(value); } else { throw new StringValueConversionException("Units not recognized: " + string); } } catch (ParseException e) { throw new StringValueConversionException("Unable to parse numeric part: " + string, e); } } else { throw new StringValueConversionException("Unable to parse bytes: " + string); } } /** * Converts a string to a number of bytes. Strings consist of a floating point value followed by * K, M, G or T for kilobytes, megabytes, gigabytes or terabytes, respectively. The * abbreviations KB, MB, GB and TB are also accepted. Matching is case insensitive. * * @param string * The string to convert * @return The Bytes value for the string * @throws StringValueConversionException */ public static Bytes valueOf(final String string) throws StringValueConversionException { return valueOf(string, Locale.getDefault(Locale.Category.FORMAT)); } /** * Converts this byte count to a string using the default locale. * * @return The string for this byte count */ @Override public String toString() { return toString(Locale.getDefault(Locale.Category.FORMAT)); } /** * Converts this byte count to a string using the given locale. * * @param locale * Locale to use for conversion * @return The string for this byte count */ public String toString(final Locale locale) { if (terabytes() >= 1.0) { return unitString(terabytes(), "TB", locale); } if (gigabytes() >= 1.0) { return unitString(gigabytes(), "GB", locale); } if (megabytes() >= 1.0) { return unitString(megabytes(), "MB", locale); } if (kilobytes() >= 1.0) { return unitString(kilobytes(), "KB", locale); } return Long.toString(value) + " bytes"; } /** * Convert value to formatted floating point number and units. * * @param value * The value * @param units * The units * @param locale * The locale * @return The formatted string */ private String unitString(final double value, final String units, final Locale locale) { return StringValue.valueOf(value, locale) + units; } /** * Compares this <code>Bytes</code> with another <code>Bytes</code> instance. * * @param other * the <code>Bytes</code> instance to compare with * @return <code>true</code> if this <code>Bytes</code> is greater than the given * <code>Bytes</code> instance */ public boolean greaterThan(final Bytes other) { if ((this == other) || (other == null)) { return false; } return bytes() > other.bytes(); } }