/** * 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. * * <p>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}. * * <p>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} 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. * * <p>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}. * * <p>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} 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. * * <p>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}. * * <p>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} that, when treated as signed, is equal to {@code value}. The * inverse operation is {@link #longValue()}. * * <p>Put another way, if {@code value} is negative, the returned result will be equal to * {@code 2^64 + value}; otherwise, the returned result will be equal to {@code value}. */ public static UnsignedLong asUnsigned(long value) { return new UnsignedLong(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. * * <p>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}. * * <p>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} 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. * * <p>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}. * * <p>To represent decimal constants less than {@code 2^63}, consider {@link #valueOf(long)} * instead. * * @since 14.0 */ public static UnsignedLong fromLongBits(long bits) { // TODO(user): consider caching small values, like Long.valueOf return new UnsignedLong(bits); }
/** * 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. * * <p>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}. * * <p>To represent decimal constants less than {@code 2^63}, consider {@link #valueOf(long)} * instead. * * @since 14.0 */ public static UnsignedLong fromLongBits(long bits) { // TODO(user): consider caching small values, like Long.valueOf return new UnsignedLong(bits); }
/** * 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. * * <p>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}. * * <p>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} 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. * * <p>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}. * * <p>To represent decimal constants less than {@code 2^63}, consider {@link #valueOf(long)} * instead. * * @since 14.0 */ public static UnsignedLong fromLongBits(long bits) { // TODO(user): consider caching small values, like Long.valueOf return new UnsignedLong(bits); }
/** * 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. * * <p>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}. * * <p>To represent decimal constants less than {@code 2^63}, consider {@link #valueOf(long)} * instead. * * @since 14.0 */ public static UnsignedLong fromLongBits(long bits) { // TODO(user): consider caching small values, like Long.valueOf return new UnsignedLong(bits); }
/** * 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. * * <p>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}. * * <p>To represent decimal constants less than {@code 2^63}, consider {@link #valueOf(long)} * instead. * * @since 14.0 */ public static UnsignedLong fromLongBits(long bits) { // TODO(user): consider caching small values, like Long.valueOf return new UnsignedLong(bits); }
/** * 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. * * <p>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}. * * <p>To represent decimal constants less than {@code 2^63}, consider {@link #valueOf(long)} * instead. * * @since 14.0 */ public static UnsignedLong fromLongBits(long bits) { // TODO(user): consider caching small values, like Long.valueOf return new UnsignedLong(bits); }
/** * 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. * * <p>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}. * * <p>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} 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. * * <p>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}. * * <p>To represent decimal constants less than {@code 2^63}, consider {@link #valueOf(long)} * instead. * * @since 14.0 */ public static UnsignedLong fromLongBits(long bits) { // TODO(user): consider caching small values, like Long.valueOf return new UnsignedLong(bits); }