storage-units/src/main/java/de/xn__ho_hia/storage_unit/Kibibyte.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.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  * Kibibyte as specified in ISO IEC 80000-13:2008 (1 Kibibyte = 1 024 Byte).
  22  */
  23 public final class Kibibyte extends StorageUnit<Kibibyte> {
  24
  25     private static final long serialVersionUID = 3798828851496657978L;
  26
  27     Kibibyte(@NonNull final BigInteger bytes) {
  28         super(bytes);
  29     }
  30
  31     /**
  32      * @param numberOfBytes
  33      *            The amount of bytes the Kibibyte contains.
  34      * @return A new Kibibyte unit with the given value.
  35      */
  36     @NonNull
  37     public static Kibibyte valueOf(@NonNull final BigInteger numberOfBytes) {
  38         return new Kibibyte(numberOfBytes);
  39     }
  40
  41     /**
  42      * @param numberOfBytes
  43      *            The amount of bytes the Kibibyte contains.
  44      * @return A new Kibibyte unit with the given value.
  45      */
  46     @NonNull
  47     public static Kibibyte valueOf(final long numberOfBytes) {
  48         return valueOf(asBigInteger(numberOfBytes));
  49     }
  50
  51     /**
  52      * @param numberOfBytes
  53      *            The amount of bytes the Kibibyte contains.
  54      * @return A new Kibibyte unit with the given value.
  55      */
  56     @NonNull
  57     public static Kibibyte valueOf(@NonNull final Long numberOfBytes) {
  58         return valueOf(numberOfBytes.longValue());
  59     }
  60
  61     @Override
  62     public Kibibyte add(final long bytesToAdd) {
  63         return new Kibibyte(addNullsafe(bytes, asBigInteger(bytesToAdd)));
  64     }
  65
  66     @Override
  67     public Kibibyte add(final StorageUnit<?> storageAmount) {
  68         return new Kibibyte(addNullsafe(bytes, storageAmount.bytes));
  69     }
  70
  71     @Override
  72     public Kibibyte divide(final long divisor) {
  73         return new Kibibyte(divideNullsafe(bytes, asBigInteger(divisor)));
  74     }
  75
  76     @Override
  77     public Kibibyte multiply(final long factor) {
  78         return new Kibibyte(multiplyNullsafe(bytes, asBigInteger(factor)));
  79     }
  80
  81     @Override
  82     public Kibibyte subtract(final long bytesToSubtract) {
  83         return new Kibibyte(subtractNullsafe(bytes, asBigInteger(bytesToSubtract)));
  84     }
  85
  86     @Override
  87     public Kibibyte subtract(final StorageUnit<?> storageAmount) {
  88         return new Kibibyte(subtractNullsafe(bytes, storageAmount.bytes));
  89     }
  90
  91     @Override
  92     protected BigInteger getNumberOfBytesPerUnit() {
  93         return StorageUnit.BYTES_IN_A_KIBIBYTE;
  94     }
  95
  96     @Override
  97     protected String getSymbol() {
  98         return "KiB"; //$NON-NLS-1$
  99     }
 100
 101     @Override
 102     protected Function<@NonNull BigInteger, @NonNull StorageUnit<?>> converter() {
 103         return StorageUnits::binaryValueOf;
 104     }
 105
 106 }