src/main/java/de/xn__ho_hia/utils/storage_unit/Petabyte.java

   1 /*
   2  * This file is part of storage-units. It is subject to the license terms in the LICENSE file found in the top-level
   3  * directory of this distribution and at http://creativecommons.org/publicdomain/zero/1.0/. No part of storage-units,
   4  * including this file, may be copied, modified, propagated, or distributed except according to the terms contained
   5  * in the LICENSE file.
   6  */
   7 package de.xn__ho_hia.utils.storage_unit;
   8
   9 import static de.xn__ho_hia.quality.null_analysis.Nullsafe.addNullsafe;
  10 import static de.xn__ho_hia.quality.null_analysis.Nullsafe.asBigInteger;
  11 import static de.xn__ho_hia.quality.null_analysis.Nullsafe.divideNullsafe;
  12 import static de.xn__ho_hia.quality.null_analysis.Nullsafe.multiplyNullsafe;
  13 import static de.xn__ho_hia.quality.null_analysis.Nullsafe.subtractNullsafe;
  14
  15 import java.math.BigInteger;
  16 import java.util.function.Function;
  17
  18 import org.eclipse.jdt.annotation.NonNull;
  19
  20 /**
  21  * Petabyte as specified in ISO IEC 80000-13:2008 (1 Petabyte = 1 000 000 000 000 000 Byte).
  22  */
  23 public class Petabyte extends StorageUnit<Petabyte> {
  24
  25     private static final long serialVersionUID = 5889808368085688387L;
  26
  27     Petabyte(@NonNull final BigInteger bytes) {
  28         super(bytes);
  29     }
  30
  31     /**
  32      * @param numberOfBytes
  33      *            The amount of bytes the Petabyte contains.
  34      * @return A new Petabyte unit with the given value.
  35      */
  36     @NonNull
  37     public static Petabyte valueOf(@NonNull final BigInteger numberOfBytes) {
  38         return new Petabyte(numberOfBytes);
  39     }
  40
  41     /**
  42      * @param numberOfBytes
  43      *            The amount of bytes the Petabyte contains.
  44      * @return A new Petabyte unit with the given value.
  45      */
  46     @NonNull
  47     public static Petabyte valueOf(final long numberOfBytes) {
  48         return new Petabyte(asBigInteger(numberOfBytes));
  49     }
  50
  51     /**
  52      * @param numberOfBytes
  53      *            The amount of bytes the Petabyte contains.
  54      * @return A new Petabyte unit with the given value.
  55      */
  56     @NonNull
  57     public static Petabyte valueOf(@NonNull final Long numberOfBytes) {
  58         return valueOf(numberOfBytes.longValue());
  59     }
  60
  61     @Override
  62     public Petabyte add(final long bytesToAdd) {
  63         return new Petabyte(addNullsafe(bytes, asBigInteger(bytesToAdd)));
  64     }
  65
  66     @Override
  67     public Petabyte add(final StorageUnit<?> storageAmount) {
  68         return new Petabyte(addNullsafe(bytes, storageAmount.bytes));
  69     }
  70
  71     @Override
  72     public Petabyte divide(final long divisor) {
  73         return new Petabyte(divideNullsafe(bytes, asBigInteger(divisor)));
  74     }
  75
  76     @Override
  77     public Petabyte multiply(final long factor) {
  78         return new Petabyte(multiplyNullsafe(bytes, asBigInteger(factor)));
  79     }
  80
  81     @Override
  82     public Petabyte subtract(final long bytesToSubtract) {
  83         return new Petabyte(subtractNullsafe(bytes, asBigInteger(bytesToSubtract)));
  84     }
  85
  86     @Override
  87     public Petabyte subtract(final StorageUnit<?> storageAmount) {
  88         return new Petabyte(subtractNullsafe(bytes, storageAmount.bytes));
  89     }
  90
  91     @Override
  92     protected BigInteger getNumberOfBytesPerUnit() {
  93         return StorageUnit.BYTES_IN_A_PETABYTE;
  94     }
  95
  96     @Override
  97     protected String getSymbol() {
  98         return "PB"; //$NON-NLS-1$
  99     }
 100
 101     @Override
 102     protected Function<@NonNull BigInteger, @NonNull StorageUnit<?>> converter() {
 103         return StorageUnits::metricValueOf;
 104     }
 105
 106 }