Java tutorial
package com.mygeopay.core.coins; /** * Copyright 2014 Andreas Schildbach * Copyright 2015 John L. Jegutanis * * Licensed 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. */ import org.bitcoinj.core.Coin; import org.bitcoinj.core.Monetary; import com.google.common.math.LongMath; import java.io.Serializable; import java.math.BigDecimal; import javax.annotation.Nonnull; import javax.annotation.Nullable; import static com.google.common.base.Preconditions.checkArgument; import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.base.Preconditions.checkState; /** * Represents a monetary value. This class is immutable. */ public class Value implements Monetary, Comparable<Value>, Serializable { /** * The type of this value */ public final ValueType type; /** * The number of units of this monetary value. */ public final long value; Value(final ValueType type, final long units) { this.type = checkNotNull(type); this.value = units; } public static Value valueOf(final ValueType type, final long units) { return new Value(type, units); } public static Value valueOf(final ValueType type, final Coin coin) { return new Value(type, coin.value); } @Override public int smallestUnitExponent() { return type.getUnitExponent(); } /** * Returns the number of units of this monetary value. */ @Override public long getValue() { return value; } public Coin toCoin() { return Coin.valueOf(value); } /** * Convert an amount expressed in the way humans are used to into units. */ public static Value valueOf(final ValueType type, final int coins, final int cents) { checkArgument(cents < 100); checkArgument(cents >= 0); checkArgument(coins >= 0); return type.oneCoin().multiply(coins).add(type.oneCoin().divide(100).multiply(cents)); } /** * Parses an amount expressed in the way humans are used to. * * This takes string in a format understood by {@link BigDecimal#BigDecimal(String)}, * for example "0", "1", "0.10", "1.23E3", "1234.5E-5". * * @throws IllegalArgumentException if you try to specify fractional units, or a value out of * range. */ public static Value parse(final ValueType type, final String str) { return parse(type, new BigDecimal(str)); } /** * Parses a {@link BigDecimal} amount expressed in the way humans are used to. * * @throws IllegalArgumentException if you try to specify fractional units, or a value out of * range. */ public static Value parse(final ValueType type, final BigDecimal decimal) { return Value.valueOf(type, decimal.movePointRight(type.getUnitExponent()).toBigIntegerExact().longValue()); } public Value add(final Value value) { checkArgument(type.equals(value.type), "Cannot add a different type"); return new Value(this.type, LongMath.checkedAdd(this.value, value.value)); } public Value add(final Coin value) { return new Value(this.type, LongMath.checkedAdd(this.value, value.value)); } public Value subtract(final Value value) { checkArgument(type.equals(value.type), "Cannot subtract a different type"); return new Value(this.type, LongMath.checkedSubtract(this.value, value.value)); } public Value subtract(String str) { return subtract(type.value(str)); } public Value multiply(final long factor) { return new Value(this.type, LongMath.checkedMultiply(this.value, factor)); } public Value divide(final long divisor) { return new Value(this.type, this.value / divisor); } public Value[] divideAndRemainder(final long divisor) { return new Value[] { new Value(this.type, this.value / divisor), new Value(this.type, this.value % divisor) }; } public long divide(final Value divisor) { checkArgument(type.equals(divisor.type), "Cannot divide with a different type"); return this.value / divisor.value; } /** * Returns true if and only if this instance represents a monetary value greater than zero, * otherwise false. */ public boolean isPositive() { return signum() == 1; } /** * Returns true if and only if this instance represents a monetary value less than zero, * otherwise false. */ public boolean isNegative() { return signum() == -1; } /** * Returns true if and only if this instance represents zero monetary value, * otherwise false. */ public boolean isZero() { return signum() == 0; } /** * Returns true if the monetary value represented by this instance is greater than that * of the given other Value, otherwise false. */ public boolean isGreaterThan(Value other) { return compareTo(other) > 0; } /** * Returns true if the monetary value represented by this instance is less than that * of the given other Value, otherwise false. */ public boolean isLessThan(Value other) { return compareTo(other) < 0; } public Value shiftLeft(final int n) { return new Value(this.type, this.value << n); } public Value shiftRight(final int n) { return new Value(this.type, this.value >> n); } @Override public int signum() { if (this.value == 0) return 0; return this.value < 0 ? -1 : 1; } public Value negate() { return new Value(this.type, -this.value); } /** * Returns the value as a 0.12 type string. More digits after the decimal place will be used * if necessary, but two will always be present. */ public String toFriendlyString() { return type.getMonetaryFormat().format(this).toString(); } /** * <p> * Returns the value as a plain string denominated in BTC. * The result is unformatted with no trailing zeroes. * For instance, a value of 150000 satoshis gives an output string of "0.0015" BTC * </p> */ public String toPlainString() { return type.getPlainFormat().format(this).toString(); } @Override public String toString() { return toPlainString() + type.getSymbol(); } @Override public boolean equals(final Object o) { if (o == this) return true; if (o == null || o.getClass() != getClass()) return false; final Value other = (Value) o; if (this.value != other.value || !this.type.equals(other.type)) return false; return true; } @Override public int hashCode() { return (int) this.value; } @Override public int compareTo(@Nonnull final Value other) { checkArgument(type.equals(other.type), "Cannot compare different types"); if (this.value == other.value) return 0; return this.value > other.value ? 1 : -1; } public boolean isDust() { return compareTo(type.minNonDust()) < 0; } public boolean isOfType(ValueType otherType) { return type.equals(otherType); } public boolean isOfType(Value otherValue) { return type.equals(otherValue.type); } /** * Check if the value is within the [min, max] range */ public boolean within(Value min, Value max) { return compareTo(min) >= 0 && compareTo(max) <= 0; } public static Value max(Value value1, Value value2) { return value1.compareTo(value2) >= 0 ? value1 : value2; } public static Value min(Value value1, Value value2) { return value1.compareTo(value2) <= 0 ? value1 : value2; } public boolean canCompare(Value other) { return canCompare(this, other); } public static boolean canCompare(@Nullable Value amount1, @Nullable Value amount2) { return amount1 != null && amount2 != null && amount1.isOfType(amount2); } }