OpenAddressHashArray

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def activeIterator: Iterator[(Int, V)]

def activeKeysIterator: Iterator[Int]

def activeSize: Int

Mainly for marking the underlying data array extent in SparseVector/SparseArray

def activeValuesIterator: Iterator[V]

def allVisitableIndicesActive: Boolean

Only gives true if isActive would return true for all i.

final def apply(i: Int): V

final def asInstanceOf[T0]: T0

def clear(): Unit

def clone(): AnyRef

def contains(i: Int): Boolean

def copy: OpenAddressHashArray[V]

def copyTo(other: OpenAddressHashArray[V]): Unit

def data: Array[V]

Returns the actual flat array of elements used.

val default: ConfigurableDefault[V]

def defaultValue: V

final def eq(arg0: AnyRef): Boolean

def equals(that: Any): Boolean

def foreach[U](f: (V) ⇒ U): Unit

Only iterates "active" elements.

final def getClass(): Class[_]

def hashCode(): Int

def index: Array[Int]

def indexAt(i: Int): Int

Gives the logical index from the physical index.

def isActive(i: Int): Boolean

Some storages (namely HashStorage) won't have active indices packed.

final def isInstanceOf[T0]: Boolean

def iterableSize: Int

How many elements must be iterated over using valueAt/indexAt.

def iterator: Iterator[(Int, V)]

Only iterates "active" elements

def keysIterator: Iterator[Int]

Only iterates "active" keys

def length: Int

implicit val manElem: ClassTag[V]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def rehash(): Unit

val size: Int

How many elements are logically stored here.

final def synchronized[T0](arg0: ⇒ T0): T0

def toArray[U >: V](implicit arg0: ClassTag[U]): Array[U]

def toIndexedSeq: List[V]

def toList: List[V]

def toMap: Map[Int, V]

def toString(): String

final def update(i: Int, v: V): Unit

def valueAt(i: Int): V

same as data(i).

def valuesIterator: Iterator[V]

Only iterates "active" elements

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def wait(): Unit

implicit val zero: Zero[V]

def finalize(): Unit