Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 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.google.common.primitives;
 
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 
 
 
 import  javax.annotation.Nullable;

A wrapper class for unsigned long values, supporting arithmetic operations.

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

See the Guava User Guide article on unsigned primitive utilities.

Author(s):
Louis Wasserman
Colin Evans
Since:
11.0
 
 @GwtCompatible(serializable = true)
 public final class UnsignedLong extends Number implements Comparable<UnsignedLong>, 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;
   }

  
Returns an UnsignedLong that, when treated as signed, is equal to value. The inverse operation is longValue().

Put another way, if value is negative, the returned result will be equal to 2^64 + value; otherwise, the returned result will be equal to value.

 
   public static UnsignedLong asUnsigned(long value) {
     return new UnsignedLong(value);
   }

  
Returns a UnsignedLong representing the same value as the specified BigInteger . This is the inverse operation of bigIntegerValue().

Throws:
IllegalArgumentException if value is negative or value >= 2^64
 
   public static UnsignedLong valueOf(BigInteger value) {
     checkNotNull(value);
     checkArgument(value.signum() >= 0 && value.bitLength() <= .,
         "value (%s) is outside the range for an unsigned long value"value);
     return asUnsigned(value.longValue());
   }

  
Returns an UnsignedLong holding the value of the specified String, parsed as an unsigned long value.

Throws:
NumberFormatException if the string does not contain a parsable unsigned long value
 
   public static UnsignedLong valueOf(String string) {
     return valueOf(string, 10);
   }

  
Returns an UnsignedLong holding the value of the specified String, parsed as an unsigned long value in the specified radix.

Throws:
NumberFormatException if the string does not contain a parsable unsigned long value, or radix is not between Character.MIN_RADIX and Character.MAX_RADIX
  public static UnsignedLong valueOf(String stringint radix) {
    return asUnsigned(UnsignedLongs.parseUnsignedLong(stringradix));
  }

  
Returns the result of adding this and val. If the result would have more than 64 bits, returns the low 64 bits of the result.
  public UnsignedLong add(UnsignedLong val) {
    checkNotNull(val);
    return asUnsigned(this. + val.value);
  }

  
Returns the result of subtracting this and val. If the result would be negative, returns the low 64 bits of the result.
  public UnsignedLong subtract(UnsignedLong val) {
    checkNotNull(val);
    return asUnsigned(this. - val.value);
  }

  
Returns the result of multiplying this and val. If the result would have more than 64 bits, returns the low 64 bits of the result.
  public UnsignedLong multiply(UnsignedLong val) {
    checkNotNull(val);
    return asUnsigned( * val.value);
  }

  
Returns the result of dividing this by val.
  public UnsignedLong divide(UnsignedLong val) {
    checkNotNull(val);
    return asUnsigned(UnsignedLongs.divide(val.value));
  }

  
Returns the remainder of dividing this by val.
  public UnsignedLong remainder(UnsignedLong val) {
    checkNotNull(val);
    return asUnsigned(UnsignedLongs.remainder(val.value));
  }

  
Returns the value of this UnsignedLong as an int.
  public int intValue() {
    return (int;
  }

  
Returns the value of this UnsignedLong as a long. This is an inverse operation to asUnsigned.

Note that if this UnsignedLong holds a value >= 2^63, the returned value will be equal to this - 2^64.

  public long longValue() {
    return ;
  }

  
Returns the value of this UnsignedLong as a float, analogous to a widening primitive conversion from long to float, and correctly rounded.
  public float floatValue() {
    @SuppressWarnings("cast")
    float fValue = (float) ( & );
    if ( < 0) {
      fValue += 0x1.0p63f;
    }
    return fValue;
  }

  
Returns the value of this UnsignedLong as a double, analogous to a widening primitive conversion from long to double, and correctly rounded.
  public double doubleValue() {
    @SuppressWarnings("cast")
    double dValue = (double) ( & );
    if ( < 0) {
      dValue += 0x1.0p63;
    }
    return dValue;
  }

  
Returns the value of this UnsignedLong as a BigInteger.
  public BigInteger bigIntegerValue() {
    BigInteger bigInt = BigInteger.valueOf( & );
    if ( < 0) {
      bigInt = bigInt.setBit(. - 1);
    }
    return bigInt;
  }
  public int compareTo(UnsignedLong o) {
    checkNotNull(o);
    return UnsignedLongs.compare(o.value);
  }
  public int hashCode() {
    return Longs.hashCode();
  }
  public boolean equals(@Nullable Object obj) {
    if (obj instanceof UnsignedLong) {
      UnsignedLong other = (UnsignedLongobj;
      return  == other.value;
    }
    return false;
  }

  
Returns a string representation of the UnsignedLong value, in base 10.
  public String toString() {
    return UnsignedLongs.toString();
  }

  
Returns a string representation of the UnsignedLong value, in base radix. If radix < Character.MIN_RADIX or radix > Character.MAX_RADIX, the radix 10 is used.
  public String toString(int radix) {
    return UnsignedLongs.toString(radix);
  }
New to GrepCode? Check out our FAQ X