All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.facebook.presto.jdbc.internal.guava.primitives.UnsignedLong Maven / Gradle / Ivy

There is a newer version: 0.289
Show newest version
/*
 * Copyright (C) 2011 The Guava Authors
 *
 * 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.
 */

package com.facebook.presto.jdbc.internal.guava.primitives;

import static com.facebook.presto.jdbc.internal.guava.base.Preconditions.checkArgument;
import static com.facebook.presto.jdbc.internal.guava.base.Preconditions.checkNotNull;

import com.facebook.presto.jdbc.internal.guava.annotations.GwtCompatible;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.io.Serializable;
import java.math.BigInteger;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * A wrapper class for unsigned {@code long} values, supporting arithmetic operations.
 *
 * 

In some cases, when speed is more important than code readability, it may be faster simply to * treat primitive {@code long} values as unsigned, using the methods from {@link UnsignedLongs}. * *

See the Guava User Guide article on unsigned * primitive utilities. * * @author Louis Wasserman * @author Colin Evans * @since 11.0 */ @GwtCompatible(serializable = true) public final class UnsignedLong extends Number implements Comparable, Serializable { private static final long UNSIGNED_MASK = 0x7fffffffffffffffL; public static final UnsignedLong ZERO = new UnsignedLong(0); public static final UnsignedLong ONE = new UnsignedLong(1); public static final UnsignedLong MAX_VALUE = new UnsignedLong(-1L); private final long value; private UnsignedLong(long value) { this.value = value; } /** * Returns an {@code UnsignedLong} corresponding to a given bit representation. The argument is * interpreted as an unsigned 64-bit value. Specifically, the sign bit of {@code bits} is * interpreted as a normal bit, and all other bits are treated as usual. * *

If the argument is nonnegative, the returned result will be equal to {@code bits}, * otherwise, the result will be equal to {@code 2^64 + bits}. * *

To represent decimal constants less than {@code 2^63}, consider {@link #valueOf(long)} * instead. * * @since 14.0 */ public static UnsignedLong fromLongBits(long bits) { // TODO(lowasser): consider caching small values, like Long.valueOf return new UnsignedLong(bits); } /** * Returns an {@code UnsignedLong} representing the same value as the specified {@code long}. * * @throws IllegalArgumentException if {@code value} is negative * @since 14.0 */ @CanIgnoreReturnValue public static UnsignedLong valueOf(long value) { checkArgument(value >= 0, "value (%s) is outside the range for an unsigned long value", value); return fromLongBits(value); } /** * Returns a {@code UnsignedLong} representing the same value as the specified {@code BigInteger}. * This is the inverse operation of {@link #bigIntegerValue()}. * * @throws IllegalArgumentException if {@code value} is negative or {@code value >= 2^64} */ @CanIgnoreReturnValue public static UnsignedLong valueOf(BigInteger value) { checkNotNull(value); checkArgument( value.signum() >= 0 && value.bitLength() <= Long.SIZE, "value (%s) is outside the range for an unsigned long value", value); return fromLongBits(value.longValue()); } /** * Returns an {@code UnsignedLong} holding the value of the specified {@code String}, parsed as an * unsigned {@code long} value. * * @throws NumberFormatException if the string does not contain a parsable unsigned {@code long} * value */ @CanIgnoreReturnValue public static UnsignedLong valueOf(String string) { return valueOf(string, 10); } /** * Returns an {@code UnsignedLong} holding the value of the specified {@code String}, parsed as an * unsigned {@code long} value in the specified radix. * * @throws NumberFormatException if the string does not contain a parsable unsigned {@code long} * value, or {@code radix} is not between {@link Character#MIN_RADIX} and {@link * Character#MAX_RADIX} */ @CanIgnoreReturnValue public static UnsignedLong valueOf(String string, int radix) { return fromLongBits(UnsignedLongs.parseUnsignedLong(string, radix)); } /** * Returns the result of adding this and {@code val}. If the result would have more than 64 bits, * returns the low 64 bits of the result. * * @since 14.0 */ public UnsignedLong plus(UnsignedLong val) { return fromLongBits(this.value + checkNotNull(val).value); } /** * Returns the result of subtracting this and {@code val}. If the result would have more than 64 * bits, returns the low 64 bits of the result. * * @since 14.0 */ public UnsignedLong minus(UnsignedLong val) { return fromLongBits(this.value - checkNotNull(val).value); } /** * Returns the result of multiplying this and {@code val}. If the result would have more than 64 * bits, returns the low 64 bits of the result. * * @since 14.0 */ public UnsignedLong times(UnsignedLong val) { return fromLongBits(value * checkNotNull(val).value); } /** * Returns the result of dividing this by {@code val}. * * @since 14.0 */ public UnsignedLong dividedBy(UnsignedLong val) { return fromLongBits(UnsignedLongs.divide(value, checkNotNull(val).value)); } /** * Returns this modulo {@code val}. * * @since 14.0 */ public UnsignedLong mod(UnsignedLong val) { return fromLongBits(UnsignedLongs.remainder(value, checkNotNull(val).value)); } /** Returns the value of this {@code UnsignedLong} as an {@code int}. */ @Override public int intValue() { return (int) value; } /** * Returns the value of this {@code UnsignedLong} as a {@code long}. This is an inverse operation * to {@link #fromLongBits}. * *

Note that if this {@code UnsignedLong} holds a value {@code >= 2^63}, the returned value * will be equal to {@code this - 2^64}. */ @Override public long longValue() { return value; } /** * Returns the value of this {@code UnsignedLong} as a {@code float}, analogous to a widening * primitive conversion from {@code long} to {@code float}, and correctly rounded. */ @Override public float floatValue() { @SuppressWarnings("cast") float fValue = (float) (value & UNSIGNED_MASK); if (value < 0) { fValue += 0x1.0p63f; } return fValue; } /** * Returns the value of this {@code UnsignedLong} as a {@code double}, analogous to a widening * primitive conversion from {@code long} to {@code double}, and correctly rounded. */ @Override public double doubleValue() { @SuppressWarnings("cast") double dValue = (double) (value & UNSIGNED_MASK); if (value < 0) { dValue += 0x1.0p63; } return dValue; } /** Returns the value of this {@code UnsignedLong} as a {@link BigInteger}. */ public BigInteger bigIntegerValue() { BigInteger bigInt = BigInteger.valueOf(value & UNSIGNED_MASK); if (value < 0) { bigInt = bigInt.setBit(Long.SIZE - 1); } return bigInt; } @Override public int compareTo(UnsignedLong o) { checkNotNull(o); return UnsignedLongs.compare(value, o.value); } @Override public int hashCode() { return Longs.hashCode(value); } @Override public boolean equals(@Nullable Object obj) { if (obj instanceof UnsignedLong) { UnsignedLong other = (UnsignedLong) obj; return value == other.value; } return false; } /** Returns a string representation of the {@code UnsignedLong} value, in base 10. */ @Override public String toString() { return UnsignedLongs.toString(value); } /** * Returns a string representation of the {@code UnsignedLong} value, in base {@code radix}. If * {@code radix < Character.MIN_RADIX} or {@code radix > Character.MAX_RADIX}, the radix {@code * 10} is used. */ public String toString(int radix) { return UnsignedLongs.toString(value, radix); } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy