Fix LGTM warning, potential int overflow bug

nitsanw · nitsanw · commit b467d291e700 · 2019-11-06T14:03:45.000+02:00
diff --git a/jctools-core/src/main/java/org/jctools/maps/NonBlockingSetInt.java b/jctools-core/src/main/java/org/jctools/maps/NonBlockingSetInt.java
@@ -63,42 +63,42 @@ private final boolean CAS_nbsi( NBSI old, NBSI nnn ) {
   private transient NBSI _nbsi;
 
   /** Create a new empty bit-vector */
-  public NonBlockingSetInt( ) { 
+  public NonBlockingSetInt( ) {
     _nbsi = new NBSI(63, new ConcurrentAutoTable(), this); // The initial 1-word set
   }
 
-  /** 
+  /**
    * Add {@code i} to the set.  Uppercase {@link Integer} version of add,
    * requires auto-unboxing.  When possible use the {@code int} version of
    * {@link #add(int)} for efficiency.
    * @throws IllegalArgumentException if i is negative.
    * @return <tt>true</tt> if i was added to the set.
    */
-  public boolean add ( final Integer i ) { 
-    return add(i.intValue()); 
+  public boolean add ( final Integer i ) {
+    return add(i.intValue());
   }
-  /** 
+  /**
    * Test if {@code o} is in the set.  This is the uppercase {@link Integer}
    * version of contains, requires a type-check and auto-unboxing.  When
    * possible use the {@code int} version of {@link #contains(int)} for
    * efficiency.
    * @return <tt>true</tt> if i was in the set.
    */
-  public boolean contains( final Object  o ) { 
+  public boolean contains( final Object  o ) {
     return o instanceof Integer && contains(((Integer) o).intValue());
   }
-  /** 
+  /**
    * Remove {@code o} from the set.  This is the uppercase {@link Integer}
    * version of remove, requires a type-check and auto-unboxing.  When
    * possible use the {@code int} version of {@link #remove(int)} for
    * efficiency.
    * @return <tt>true</tt> if i was removed to the set.
    */
-  public boolean remove( final Object  o ) { 
+  public boolean remove( final Object  o ) {
     return o instanceof Integer && remove(((Integer) o).intValue());
   }
 
-  /** 
+  /**
    * Add {@code i} to the set.  This is the lower-case '{@code int}' version
    * of {@link #add} - no autoboxing.  Negative values throw
    * IllegalArgumentException.
@@ -109,20 +109,20 @@ public boolean add( final int i ) {
     RangeUtil.checkPositiveOrZero(i, "i");
     return _nbsi.add(i);
   }
-  /** 
+  /**
    * Test if {@code i} is in the set.  This is the lower-case '{@code int}'
    * version of {@link #contains} - no autoboxing.
    * @return <tt>true</tt> if i was int the set.
    */
   public boolean contains( final int i ) { return i >= 0 && _nbsi.contains(i); }
-  /** 
+  /**
    * Remove {@code i} from the set.  This is the fast lower-case '{@code int}'
    * version of {@link #remove} - no autoboxing.
    * @return <tt>true</tt> if i was added to the set.
    */
   public boolean remove  ( final int i ) { return i >= 0 && _nbsi.remove(i); }
-  
-  /** 
+
+  /**
    * Current count of elements in the set.  Due to concurrent racing updates,
    * the size is only ever approximate.  Updates due to the calling thread are
    * immediately visible to calling thread.
@@ -132,7 +132,7 @@ public boolean add( final int i ) {
   /** Approx largest element in set; at least as big (but max might be smaller).  */
   public int length() { return _nbsi._bits.length<<6; }
   /** Empty the bitvector. */
-  public void    clear   (             ) { 
+  public void    clear   (             ) {
     NBSI cleared = new NBSI(63, new ConcurrentAutoTable(), this); // An empty initial NBSI
     while( !CAS_nbsi( _nbsi, cleared ) ) // Spin until clear works
       ;
@@ -153,26 +153,26 @@ private class iter implements Iterator<Integer> {
     int _prev = -1;
     iter() { _nbsi2 = _nbsi; advance(); }
     public boolean hasNext() { return _idx != -2; }
-    private void advance() {     
+    private void advance() {
       while( true ) {
         _idx++;                 // Next index
         while( (_idx>>6) >= _nbsi2._bits.length ) { // Index out of range?
           if( _nbsi2._new == null ) { // New table?
             _idx = -2;          // No, so must be all done
-            return;             // 
+            return;             //
           }
           _nbsi2 = _nbsi2._new; // Carry on, in the new table
         }
         if( _nbsi2.contains(_idx) ) return;
       }
     }
-    public Integer next() { 
+    public Integer next() {
       if( _idx == -1 ) throw new NoSuchElementException();
       _prev = _idx;
       advance();
       return _prev;
     }
-    public void remove() { 
+    public void remove() {
       if( _prev == -1 ) throw new IllegalStateException();
       _nbsi2.remove(_prev);
       _prev = -1;
@@ -186,10 +186,10 @@ private void writeObject(java.io.ObjectOutputStream s) throws IOException  {
     final NBSI nbsi = _nbsi;    // The One Field is transient
     final int len = _nbsi._bits.length<<6;
     s.writeInt(len);            // Write max element
-    for( int i=0; i<len; i++ ) 
+    for( int i=0; i<len; i++ )
       s.writeBoolean( _nbsi.contains(i) );
   }
-  
+
   // --- readObject --------------------------------------------------------
   // Read a CHM from a stream
   private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException  {
@@ -216,7 +216,7 @@ private static final class NBSI {
     private static final int _Lscale = UNSAFE.arrayIndexScale(long[].class);
     private static long rawIndex(final long[] ary, final int idx) {
       assert idx >= 0 && idx < ary.length;
-      return _Lbase + idx * _Lscale;
+      return _Lbase + (idx * (long)_Lscale);
     }
     private final boolean CAS( int idx, long old, long nnn ) {
       return UNSAFE.compareAndSwapLong( _bits, rawIndex(_bits, idx), old, nnn );
@@ -246,9 +246,9 @@ private final boolean CAS_new( NBSI nnn ) {
     // Every 64th bit is put in it's own recursive bitvector.  If the low 6 bits
     // are all set, we shift them off and recursively operate on the _nbsi64 set.
     private final NBSI _nbsi64;
-    
-    private NBSI( int max_elem, ConcurrentAutoTable ctr, NonBlockingSetInt nonb ) { 
-      super(); 
+
+    private NBSI( int max_elem, ConcurrentAutoTable ctr, NonBlockingSetInt nonb ) {
+      super();
       _non_blocking_set_int = nonb;
       _size = ctr;
       _copyIdx  = ctr == null ? null : new AtomicInteger();
@@ -260,13 +260,13 @@ private NBSI( int max_elem, ConcurrentAutoTable ctr, NonBlockingSetInt nonb ) {
       _nbsi64 = ((max_elem+1)>>>6) == 0 ? null : new NBSI((max_elem+1)>>>6, null, null);
       _sum_bits_length = _bits.length + (_nbsi64==null ? 0 : _nbsi64._sum_bits_length);
     }
-    
+
     // Lower-case 'int' versions - no autoboxing, very fast.
     // 'i' is known positive.
     public boolean add( final int i ) {
       // Check for out-of-range for the current size bit vector.
       // If so we need to grow the bit vector.
-      if( (i>>6) >= _bits.length ) 
+      if( (i>>6) >= _bits.length )
         return install_larger_new_bits(i). // Install larger pile-o-bits (duh)
           help_copy().add(i);              // Finally, add to the new table
 
@@ -280,7 +280,7 @@ public boolean add( final int i ) {
 
       final long mask = mask(j);
       long old;
-      do { 
+      do {
         old = nbsi._bits[j>>6]; // Read old bits
         if( old < 0 )           // Not mutable?
           // Not mutable: finish copy of word, and retry on copied word
@@ -305,7 +305,7 @@ public boolean remove( final int i ) {
 
       final long mask = mask(j);
       long old;
-      do { 
+      do {
         old = nbsi._bits[j>>6]; // Read old bits
         if( old < 0 )           // Not mutable?
           // Not mutable: finish copy of word, and retry on copied word
@@ -315,8 +315,8 @@ public boolean remove( final int i ) {
       _size.add(-1);
       return true;
     }
-    
-    public boolean contains( final int i ) { 
+
+    public boolean contains( final int i ) {
       if( (i>>6) >= _bits.length ) // Out of bounds?  Not in this array!
         return _new != null && help_copy().contains(i);
 
@@ -334,9 +334,9 @@ public boolean contains( final int i ) {
         // Not mutable: finish copy of word, and retry on copied word
         return help_copy_impl(i).help_copy().contains(i);
       // Yes mutable: test & return bit
-      return (old & mask) != 0; 
+      return (old & mask) != 0;
     }
-    
+
     public int size() { return (int)_size.get(); }
 
     // Must grow the current array to hold an element of size i
@@ -385,7 +385,7 @@ private NBSI help_copy() {
       return _new;
     }
 
-    // Help copy this one word.  State Machine.  
+    // Help copy this one word.  State Machine.
     // (1) If not "made immutable" in the old array, set the sign bit to make
     //     it immutable.
     // (2) If non-zero in old array & zero in new, CAS new from 0 to copy-of-old
@@ -413,7 +413,7 @@ private NBSI help_copy_impl( int i ) {
         if( old.CAS( j>>6, oldbits, bits ) ) {
           if( oldbits == 0 ) _copyDone.addAndGet(1);
           break;                // Success - old array word is now immutable
-        } 
+        }
         bits = old._bits[j>>6]; // Retry if CAS failed
       }
 
@@ -434,7 +434,7 @@ private NBSI help_copy_impl( int i ) {
         if( old.CAS( j>>6, bits, mask(63) ) )
           _copyDone.addAndGet(1); // One more word finished copying
       }
-      
+
       // Now in state 4: zero (and immutable) in old
 
       // Return the self bitvector for 'fluid' programming style
@@ -456,7 +456,7 @@ private void print(int d) {
         x = x._nbsi64;
       }
       print(d,buf.toString());
-      
+
       x = this;
       while( x != null ) {
         for( int i=0; i<x._bits.length; i++ )
@@ -472,5 +472,5 @@ private void print(int d) {
         _new.print(d+1);
       }
     }
-  }    
+  }
 }
