ByteBufferHashMap

A HashMap implementation using a serialized ByteBuffer for key data and another one for value data. Key data is required to hold fixed-width values while the value data will be written back-to-back as new data is inserted into the map. Key data is stored in the following format:

  .------------------------ Offset into value data (4 bytes)
  |   .-------------------- Hash code (4 bytes)
  |   |
  |   |        .----------- Fixed-width fields of key data
  |   |        |        .-- Padding for 8 byte word alignment
  V   V        V        V
+---+---+-------------+---+
|   |   | ... ... ... |   |
+---+---+-------------+---+
 \-----/ \------------/\--/
  header      body    padding

If key has variable length data, then it should be appended to the value data. The offset+hash code is read as a single long where LSB is used for hash code while MSB is used for offset, so the two can be reverse in actual memory layout on big-endian machines. Since there is no disk storage of this map so no attempt is made to have consistent endianness or memory layout of the data.

Rehash of the map (when loadFactor exceeds) moves around the above key fields to create a new array as per the new hash locations. The value fields are left untouched with the headers of keys having the offsets into value array as before the rehash.

Linear Supertypes

AnyRef, Any

Known Subclasses

DictionaryMap

Instance Constructors

new ByteBufferHashMap(initialCapacity: Int, loadFactor: Double, keySize: Int, valueSize: Int, allocator: BufferAllocator, keyData: ByteBufferData = null, valueData: ByteBufferData = null, valueDataPosition: Long = 0L)

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
val allocator: BufferAllocator

Attributes
protected
final def asInstanceOf[T0]: T0

Definition Classes
Any
final def capacity: Int
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
final def getKeyData: ByteBufferData
final def getValueData: ByteBufferData
def handleExisting(mapKeyObject: AnyRef, mapKeyOffset: Long): Int

Attributes
protected
def handleNew(mapKeyObject: AnyRef, mapKeyOffset: Long): Int

Attributes
protected
final def handleNewInsert(): Unit

Double the table's size and re-hash everything.
Double the table's size and re-hash everything.

Attributes
protected
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
var keyData: ByteBufferData

Attributes
protected
val loadFactor: Double
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def newInsert(baseObject: AnyRef, baseOffset: Long, numKeyBytes: Int, numBytes: Int): Int

Attributes
protected
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def putBufferIfAbsent(baseObject: AnyRef, baseOffset: Long, numKeyBytes: Int, numBytes: Int, hash: Int): Int

Insert raw bytes with given hash code into the map if not present.
Insert raw bytes with given hash code into the map if not present. The key bytes for comparison is assumed to be at the start having "numKeyBytes" size, while the total size including value is "numBytes". Normally one would have serialized form of key bytes followed by self-contained serialized form of value bytes (i.e. including its size).
This method will handle writing only the 8 byte key header while any additional fixed-width bytes to be tracked in read/write should be taken care of in handleExisting and handleNew. These bytes are not part of key equality check itself.
baseObject
the base object for the bytes as required by Unsafe API
baseOffset
the base offset for the bytes as required by Unsafe API
numKeyBytes
number of bytes used by the key which should be at the start of "baseObject" with value after that
numBytes
the total number of bytes used by key and value together (excluding the four bytes of "numKeyBytes" itself)
hash
the hash code of key bytes
final def release(): Unit
final def reset(): Unit
final def size: Int
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
var valueData: ByteBufferData

Attributes
protected
var valueDataPosition: Long

Attributes
protected
final def valueDataSize: Long
val valueSize: Int

Attributes
protected
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Doc: package collection

class ByteBufferHashMap extends AnyRef

Instance Constructors

new ByteBufferHashMap(initialCapacity: Int, loadFactor: Double, keySize: Int, valueSize: Int, allocator: BufferAllocator, keyData: ByteBufferData = null, valueData: ByteBufferData = null, valueDataPosition: Long = 0L)

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val allocator: BufferAllocator

final def asInstanceOf[T0]: T0

final def capacity: Int

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

final def getKeyData: ByteBufferData

final def getValueData: ByteBufferData

def handleExisting(mapKeyObject: AnyRef, mapKeyOffset: Long): Int

def handleNew(mapKeyObject: AnyRef, mapKeyOffset: Long): Int

final def handleNewInsert(): Unit

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

var keyData: ByteBufferData

val loadFactor: Double

final def ne(arg0: AnyRef): Boolean

final def newInsert(baseObject: AnyRef, baseOffset: Long, numKeyBytes: Int, numBytes: Int): Int

final def notify(): Unit

final def notifyAll(): Unit

final def putBufferIfAbsent(baseObject: AnyRef, baseOffset: Long, numKeyBytes: Int, numBytes: Int, hash: Int): Int

final def release(): Unit

final def reset(): Unit

final def size: Int

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

def toString(): String

var valueData: ByteBufferData

var valueDataPosition: Long

final def valueDataSize: Long

val valueSize: Int

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped