org.apache.brooklyn.util.text.ByteSizeStrings java code examples

/** Returns a size string using metric suffixes from {@link ByteSizeStrings#metric()}, e.g. 23.5MB */
public static String makeSizeString(long sizeInBytes) {
  return ByteSizeStrings.metric().makeSizeString(sizeInBytes);
}

/** Returns a size string using Java suffixes from {@link ByteSizeStrings#java()}, e.g. 23m */
public static String makeJavaSizeString(long sizeInBytes) {
  return ByteSizeStrings.java().makeSizeString(sizeInBytes);
}

public static long parse(String sizeString) {
  return parse(sizeString, null);
}
public static long parse(String sizeString, String defaultUnits) {

/** Returns a size string using ISO suffixes from {@link ByteSizeStrings#iso()}, e.g. 23.5MiB */
public static String makeISOSizeString(long sizeInBytes) {
  return ByteSizeStrings.iso().makeSizeString(sizeInBytes);
}

public void testParse() {
  assertEquals(ByteSizeStrings.parse("1", "k"), 1024);
  assertEquals(ByteSizeStrings.parse("1b"), 1);
  assertEquals(ByteSizeStrings.parse("1k"), 1024);
  assertEquals(ByteSizeStrings.parse("1m"), 1024*1024);
  assertEquals(ByteSizeStrings.parse("1g"), 1024*1024*1024);
  assertEquals(ByteSizeStrings.parse("1t"), 1024L*1024*1024*1024);
  assertEquals(ByteSizeStrings.parse("64.0 KiB"), 65536);
  assertEquals(ByteSizeStrings.parse("64.0 KB"), 64000);
  assertEquals(ByteSizeStrings.parse("64.0k"), 65536);
  assertEquals(ByteSizeStrings.parse("64k"), 65536);
  assertEquals(ByteSizeStrings.parse("64 k"), 65536);
  assertEquals(ByteSizeStrings.parse("0.5t"), 512L*1024*1024*1024);
  assertEquals(ByteSizeStrings.parse("1", "k"), 1024);
  assertEquals(ByteSizeStrings.parse("1k", "m"), 1024);
  assertEquals(ByteSizeStrings.parse("1k", "m", ByteSizeStrings.metric()), 1000);

public void assertUsedMemoryLessThan(String event, long max) {
  noteUsedMemory(event);
  long nowUsed = usedMemory.peekLast();
  if (nowUsed > max) {
    // aggressively try to force GC
    Time.sleep(Duration.ONE_SECOND);
    usedMemory.removeLast();
    noteUsedMemory(event+" (extra GC)");
    nowUsed = usedMemory.peekLast();
    if (nowUsed > max) {
      Assert.fail("Too much memory used - "+ByteSizeStrings.java().apply(nowUsed)+" > max "+ByteSizeStrings.java().apply(max));
    }
  }
}
public void assertUsedMemoryMaxDelta(String event, long deltaMegabytes) {

/** Setup renderer hints for the MXBean attributes. */
public static void init() {
  if (initialized.getAndSet(true)) return;
  RendererHints.register(UsesJavaMXBeans.USED_HEAP_MEMORY, RendererHints.displayValue(ByteSizeStrings.metric()));
  RendererHints.register(UsesJavaMXBeans.INIT_HEAP_MEMORY, RendererHints.displayValue(ByteSizeStrings.metric()));
  RendererHints.register(UsesJavaMXBeans.MAX_HEAP_MEMORY, RendererHints.displayValue(ByteSizeStrings.metric()));
  RendererHints.register(UsesJavaMXBeans.COMMITTED_HEAP_MEMORY, RendererHints.displayValue(ByteSizeStrings.metric()));
  RendererHints.register(UsesJavaMXBeans.NON_HEAP_MEMORY_USAGE, RendererHints.displayValue(ByteSizeStrings.metric()));
  RendererHints.register(UsesJavaMXBeans.TOTAL_PHYSICAL_MEMORY_SIZE, RendererHints.displayValue(ByteSizeStrings.metric()));
  RendererHints.register(UsesJavaMXBeans.FREE_PHYSICAL_MEMORY_SIZE, RendererHints.displayValue(ByteSizeStrings.metric()));
  RendererHints.register(UsesJavaMXBeans.START_TIME, RendererHints.displayValue(Time.toDateString()));
  RendererHints.register(UsesJavaMXBeans.UP_TIME, RendererHints.displayValue(Duration.millisToStringRounded()));
  RendererHints.register(UsesJavaMXBeans.PROCESS_CPU_TIME, RendererHints.displayValue(Duration.millisToStringRounded()));
  RendererHints.register(UsesJavaMXBeans.PROCESS_CPU_TIME_FRACTION_LAST, RendererHints.displayValue(MathFunctions.percent(4)));
  RendererHints.register(UsesJavaMXBeans.PROCESS_CPU_TIME_FRACTION_IN_WINDOW, RendererHints.displayValue(MathFunctions.percent(4)));
}

/**
 * Format the {@literal size} bytes as a String.
 */
public String makeSizeString(long size) {
  return makeSizeString(size, precision);
}

public void testBuilder() {
  ByteSizeStrings strings = ByteSizeStrings.builder()
      .bytesPerMetricUnit(1024)
      .precision(4)
      .lowerLimit(5)
      .maxLen(4)
      .suffixBytes("b")
      .suffixKilo("kb")
      .suffixMega("Mb")
      .suffixGiga("Gb")
      .suffixTera("Tb")
      .addSpace()
      .build();
  assertEquals(strings.makeSizeString(-1), "-1 b");
  assertEquals(strings.makeSizeString(0), "0 b");
  assertEquals(strings.makeSizeString(999), "999 b");
  assertEquals(strings.makeSizeString(1024), "1024 b");
  assertEquals(strings.makeSizeString(1234), "1234 b");
  assertEquals(strings.makeSizeString(2345), "2345 b");
  assertEquals(strings.makeSizeString(4096), "4096 b");
  assertEquals(strings.makeSizeString(4567), "4567 b");
  assertEquals(strings.makeSizeString(6789), "6.630 kb");
  assertEquals(strings.makeSizeString(65535), "64.00 kb");
  assertEquals(strings.makeSizeString(23456789L), "22.37 Mb");
  assertEquals(strings.makeSizeString(23456789012L), "21.85 Gb");
  assertEquals(strings.makeSizeString(23456789012345L), "21.33 Tb");
  assertEquals(strings.makeSizeString(Long.MAX_VALUE), "8388608 Tb");
}

public void testFormatter() {
  ByteSizeStrings iso = ByteSizeStrings.iso();
  assertEquals(String.format("%s", iso.formatted(23456789L)), "22.4 MiB");
  assertEquals(String.format("%.6s", iso.formatted(23456789L)), "22.3701 MiB");
  assertEquals(String.format("%#s", iso.formatted(23456789L)), "23.5 MB");
}

  matchedMode = java();
} else {
  throw new IllegalArgumentException("Cannot parse '"+sizeStringOriginal+"' as a size string (as '"+sizeString+"' "+units+")");

public void testFunction() {
  ByteSizeStrings iso = ByteSizeStrings.iso();
  Iterable<String> bytes = Iterables.transform(Arrays.asList(23456789L, 23456789012L, 23456789012345L), iso);
  assertEquals(Iterables.get(bytes, 0), "22.4 MiB");
  assertEquals(Iterables.get(bytes, 1), "21.8 GiB");
  assertEquals(Iterables.get(bytes, 2), "21.3 TiB");
}

/**
 * Returns an immutable {@link ByteSizeStrings} formatter using the builder configuration.
 */
public ByteSizeStrings build() {
  String space = addSpace ? " " : "";
  return new ByteSizeStrings(space + suffixBytes, space + suffixKilo, space + suffixMega, space + suffixGiga,
      space + suffixTera, bytesPerMetricUnit, maxLen, precision, lowerLimit);
}

public void testISOSizeString() {
  assertEquals(ByteSizeStrings.iso().makeSizeString(-1), "-1 B");
  assertEquals(ByteSizeStrings.iso().makeSizeString(0), "0 B");
  assertEquals(ByteSizeStrings.iso().makeSizeString(999), "999 B");
  assertEquals(ByteSizeStrings.iso().makeSizeString(1024), "1024 B");
  assertEquals(ByteSizeStrings.iso().makeSizeString(1234), "1234 B");
  assertEquals(ByteSizeStrings.iso().makeSizeString(2345), "2.29 KiB");
  assertEquals(ByteSizeStrings.iso().makeSizeString(4096), "4 KiB");
  assertEquals(ByteSizeStrings.iso().makeSizeString(4567), "4.46 KiB");
  assertEquals(ByteSizeStrings.iso().makeSizeString(6789), "6.63 KiB");
  assertEquals(ByteSizeStrings.iso().makeSizeString(65535), "64.0 KiB");
  assertEquals(ByteSizeStrings.iso().makeSizeString(23456789L), "22.4 MiB");
  assertEquals(ByteSizeStrings.iso().makeSizeString(23456789012L), "21.8 GiB");
  assertEquals(ByteSizeStrings.iso().makeSizeString(23456789012345L), "21.3 TiB");
  assertEquals(ByteSizeStrings.iso().makeSizeString(Long.MAX_VALUE), "8388608 TiB");
}

protected long noteUsedMemory(String message) {
  Time.sleep(Duration.millis(200));
  for (HaMgmtNode n: nodes) {
    ((AbstractManagementContext)n.mgmt).getGarbageCollector().gcIteration();
  }
  System.gc(); System.gc();
  Time.sleep(Duration.millis(50));
  System.gc(); System.gc();
  long mem = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
  usedMemory.addLast(mem);
  log.info("Memory used - "+message+": "+ByteSizeStrings.java().apply(mem));
  return mem;
}
public void assertUsedMemoryLessThan(String event, long max) {

/**
 * Setup renderer hints.
 */
public static void init() {
  if (initialized.getAndSet(true)) return;
  final Function<Double, Long> longValue = new Function<Double, Long>() {
    @Override
    public Long apply(@Nullable Double input) {
      if (input == null) return null;
      return input.longValue();
    }
  };
  RendererHints.register(CPU_USAGE, RendererHints.displayValue(MathFunctions.percent(2)));
  RendererHints.register(AVERAGE_CPU_USAGE, RendererHints.displayValue(MathFunctions.percent(2)));
  RendererHints.register(USED_MEMORY_PERCENT, RendererHints.displayValue(MathFunctions.percent(2)));
  RendererHints.register(AVERAGE_USED_MEMORY_PERCENT, RendererHints.displayValue(MathFunctions.percent(2)));
  RendererHints.register(FREE_MEMORY, RendererHints.displayValue(Functionals.chain(MathFunctions.times(1000L), ByteSizeStrings.metric())));
  RendererHints.register(TOTAL_MEMORY, RendererHints.displayValue(Functionals.chain(MathFunctions.times(1000L), ByteSizeStrings.metric())));
  RendererHints.register(USED_MEMORY, RendererHints.displayValue(Functionals.chain(MathFunctions.times(1000L), ByteSizeStrings.metric())));
  RendererHints.register(USED_MEMORY_DELTA_PER_SECOND_LAST, RendererHints.displayValue(Functionals.chain(longValue, ByteSizeStrings.metric())));
  RendererHints.register(USED_MEMORY_DELTA_PER_SECOND_IN_WINDOW, RendererHints.displayValue(Functionals.chain(longValue, ByteSizeStrings.metric())));
}

/**
 * A {@link Function} implementation that formats its input using the current {@link ByteSizeStrings} values.
 */
@Override
@Nullable
public String apply(@Nullable Long input) {
  if (input == null) return null;
  return makeSizeString(input);
}

  @Override
  public void formatTo(Formatter formatter, int flags, int width, int precision) {
    boolean alternate = (flags & FormattableFlags.ALTERNATE) == FormattableFlags.ALTERNATE;
    ByteSizeStrings strings = alternate ? ByteSizeStrings.metric() : ByteSizeStrings.this;
    if (precision != -1) {
      formatter.format("%s", strings.makeSizeString(bytes, precision));
    } else {
      formatter.format("%s", strings.makeSizeString(bytes));
    }
  }
};

public void testJavaSizeString() {
  assertEquals(ByteSizeStrings.java().makeSizeString(-1), "-1");
  assertEquals(ByteSizeStrings.java().makeSizeString(0), "0");
  assertEquals(ByteSizeStrings.java().makeSizeString(999), "999");
  assertEquals(ByteSizeStrings.java().makeSizeString(1024), "1024");
  assertEquals(ByteSizeStrings.java().makeSizeString(1234), "1234");
  assertEquals(ByteSizeStrings.java().makeSizeString(2345), "2345");
  assertEquals(ByteSizeStrings.java().makeSizeString(4096), "4096");
  assertEquals(ByteSizeStrings.java().makeSizeString(4567), "4567");
  assertEquals(ByteSizeStrings.java().makeSizeString(6789), "6789");
  assertEquals(ByteSizeStrings.java().makeSizeString(65535), "64k");
  assertEquals(ByteSizeStrings.java().makeSizeString(23456789L), "22m");
  assertEquals(ByteSizeStrings.java().makeSizeString(23456789012L), "22g");
  assertEquals(ByteSizeStrings.java().makeSizeString(23456789012345L), "21000g");
  assertEquals(ByteSizeStrings.java().makeSizeString(Long.MAX_VALUE), "8388608000g");
}

/**
 * Format the {@literal size} bytes as a String with the given precision.
 */
public String makeSizeString(long size, int precision) {
  long t = size;
  if (t==0) return "0"+suffixBytes;
  if (t<0) return "-"+makeSizeString(-t);
  long b = t%bytesPerMetricUnit;
  t = t/bytesPerMetricUnit;
  long kb = t%bytesPerMetricUnit;
  t = t/bytesPerMetricUnit;
  long mb = t%bytesPerMetricUnit;
  t = t/bytesPerMetricUnit;
  long gb = t%bytesPerMetricUnit;
  t = t/bytesPerMetricUnit;
  long tb = t;
  if (tb>lowerLimit)
    return Strings.makeRealString(tb + (1.0*gb/bytesPerMetricUnit), -1, precision, 0) + suffixTera;
  if (gb>lowerLimit)
    return Strings.makeRealString((tb*bytesPerMetricUnit) + gb + (1.0*mb/bytesPerMetricUnit), maxLen, precision, 0) + suffixGiga;
  if (mb>lowerLimit)
    return Strings.makeRealString((gb*bytesPerMetricUnit) + mb + (1.0*kb/bytesPerMetricUnit), maxLen, precision, 0) + suffixMega;
  if (kb>lowerLimit)
    return Strings.makeRealString((mb*bytesPerMetricUnit) + kb + (1.0*b/bytesPerMetricUnit), maxLen, precision, 0) + suffixKilo;
  return (kb*bytesPerMetricUnit) + b + suffixBytes;
}

Javadoc

A formatter to pretty-print numeric values representing sizes in byes.

The ByteSizeStrings#builder() presents a fluent interface to create various configurations of formatting. The defaults produce metric units in multiples of 1000 bytes at a precision of three significant figures. This is the way disk space is normally measured, for example 128.1GB.

Alternatively the ByteSizeStrings#iso() convenience method produces ISO standard units in multiples of 1024 bytes, with the same precision as the metric output. This is how RAM is normally measured, for example 12.4MiBor 1.04GiB.

Finally, the ByteSizeStrings#java() convenience method will produce strings suitable for use with a Java command line, as part of the -Xmsor -Xmx options. These output integer values only, so values up to 10GB will be reported in MB to preserve accuracy. For size values over 1000GB, the output will still be formatted as GB but rounded to a mutiple of 1000.

The class is immutable and thread safe once built and a single instance of the three pre-defined configurations is created and returned buy the methods described above.

Most used methods

metric
Default byte size formatter using metric multiples of 1000.
java
Format byte sizes suitable for Java -Xms arguments.
makeSizeString
Format the size bytes as a String with the given precision.
parse
parses the given string as a byte size string, e.g. "4gb"
iso
Formats byte sizes using ISO standard suffixes and binary multiples of 1024
<init>
apply
A Function implementation that formats its input using the current ByteSizeStrings values.
builder
Returns a builder for a ByteSizeStrings formatter.
formatted
Returns a Formattable object that can be used with String#format(String,Object...). When used as the

Popular in Java

Running tasks concurrently on multiple threads
setRequestProperty (URLConnection)
getSharedPreferences (Context)
requestLocationUpdates (LocationManager)
InputStreamReader (java.io)
A class for turning a byte stream into a character stream. Data read from the source input stream is
Enumeration (java.util)
A legacy iteration interface.New code should use Iterator instead. Iterator replaces the enumeration
Hashtable (java.util)
A plug-in replacement for JDK1.5 java.util.Hashtable. This version is based on org.cliffc.high_scale
Vector (java.util)
Vector is an implementation of List, backed by an array and synchronized. All optional operations in
Loader (org.hibernate.loader)
Abstract superclass of object loading (and querying) strategies. This class implements useful common
Logger (org.slf4j)
The org.slf4j.Logger interface is the main user entry point of SLF4J API. It is expected that loggin
Best IntelliJ plugins

How to useByteSizeStrings in org.apache.brooklyn.util.text

Best Java code snippets using org.apache.brooklyn.util.text.ByteSizeStrings (Showing top 20 results out of 315)

How to use
ByteSizeStrings
in
org.apache.brooklyn.util.text