AryInt.java

Go to the documentation of this file.

package com.cliffc.aa.util;
 
import java.util.Arrays;
import java.util.Collection;
import java.util.function.IntUnaryOperator;
 
// ArrayList with saner syntax
public class AryInt {
  public int[] _es;
  public int _len;
  public AryInt(int[] es) { this(es,es.length); }
  public AryInt(int[] es, int len) { _es=es; _len=len; }
  public AryInt() { this(new int[1],0); }
 
  public boolean isEmpty() { return _len==0; }
  public int len() { return _len; }
  public int at( int i ) {
    range_check(i);
    return _es[i];
  }
  public int atX( int i ) {
    return i < _len ? _es[i] : 0;
  }
  public int last( ) {
    range_check(0);
    return _es[_len-1];
  }
 
  public int pop( ) {
    range_check(0);
    return _es[--_len];
  }
 
  public AryInt push( int e ) {
    if( _len >= _es.length ) _es = Arrays.copyOf(_es,Math.max(1,_es.length<<1));
    _es[_len++] = e;
    return this;
  }
 
  public void insert( int i, int e ) {
    if( i < 0 || i>_len )
      throw new ArrayIndexOutOfBoundsException(""+i+" >= "+_len);
    if( _len >= _es.length ) _es = Arrays.copyOf(_es,Math.max(1,_es.length<<1));
    System.arraycopy(_es,i,_es,i+1,(_len++)-i);
    _es[i] = e;
  }
 
  public int del( int i ) {
    range_check(i);
    int tmp = _es[i];
    _es[i]=_es[--_len];
    return tmp;
  }
 
  public int remove( int i ) {
    range_check(i);
    int e = _es[i];
    System.arraycopy(_es,i+1,_es,i,(--_len)-i);
    return e;
  }
 
  public void clear( ) { Arrays.fill(_es,0,_len,0); _len=0; }
 
  // Extend and set
  public int setX( int i, int e ) {
    while( i>= _es.length ) _es = Arrays.copyOf(_es,_es.length<<1);
    if( i >= _len ) _len = i+1;
    return (_es[i] = e);
  }
 
  public int set( int i, int e ) {
    range_check(i);
    return (_es[i] = e);
  }
 
  public AryInt set_as( int e ) { _es[0] = e; _len=1; return this; }
  public AryInt set_len( int len ) {
    if( len > _len )
      while( len>= _es.length ) _es = Arrays.copyOf(_es,_es.length<<1);
    _len = len;
    while( _es.length > (len<<1) ) // Shrink if hugely too large
      _es = Arrays.copyOf(_es,_es.length>>1);
    return this;
  }
 
  public AryInt addAll( Collection<? extends Integer> c ) { for( int e : c ) push(e); return this; }
 
  public AryInt addAll( int[] es ) {
    if( es.length==0 ) return this;
    while( _len+es.length > _es.length ) _es = Arrays.copyOf(_es,_es.length<<1);
    System.arraycopy(es,0,_es,_len,es.length);
    _len += es.length;
    return this;
  }
 
  public AryInt map_update( IntUnaryOperator f ) { for( int i = 0; i<_len; i++ ) _es[i] = f.applyAsInt(_es[i]); return this; }
 
  public int[] asAry() { return _len==_es.length ? _es : Arrays.copyOf(_es,_len); }
 
  public void sort_update() { Arrays.sort(_es, 0, _len);  }
  public int find( int e ) {
    for( int i=0; i<_len; i++ )  if( _es[i]==e )  return i;
    return -1;
  }
 
  @Override public String toString() {
    SB sb = new SB().p('[');
    for( int i=0; i<_len; i++ )
      sb.p(_es[i]).p(',');
    return sb.unchar().p(']').toString();
  }
 
  private void range_check( int i ) {
    if( i < 0 || i>=_len )
      throw new ArrayIndexOutOfBoundsException(""+i+" >= "+_len);
  }
 
  // Binary search sorted _es.  Returns insertion point.
  // Undefined results if _es is not sorted.
  public int binary_search( int e ) {
    int lo=0, hi=_len-1;
    while( lo <= hi ) {
      int mid = (hi + lo) >>> 1; // midpoint, rounded down
      int mval = _es[mid];
      if( e==mval ) {
        // If dups, get to the first.
        while( mid>0 && e==_es[mid-1] ) mid--;
        return mid;
      }
      if( e >mval ) lo = mid+1;
      else          hi = mid-1;
    }
    return lo;
  }
 
  // Note that the hashCode() and equals() are not invariant to changes in the
  // underlying array.  If the hashCode() is used (e.g., inserting into a
  // HashMap) and the then the array changes, the hashCode() will change also.
  @Override public boolean equals( Object o ) {
    if( this==o ) return true;
    if( !(o instanceof AryInt) ) return false;
    AryInt ary = (AryInt)o;
    if( _len != ary._len ) return false;
    if( _es == ary._es ) return true;
    for( int i=0; i<_len; i++ )
      if( _es[i] != ary._es[i] )
        return false;
    return true;
  }
  @Override public int hashCode( ) {
    int sum=_len;
    for( int i=0; i<_len; i++ )
      sum += _es[i];
    return sum;
  }
}