ByteArrayOrdinalMap (hollow 4.6.3 API)

java.lang.Object
- com.netflix.hollow.core.memory.ByteArrayOrdinalMap

```
public class ByteArrayOrdinalMap
extends java.lang.Object
```
This data structure maps byte sequences to ordinals. This is a hash table.
The pointersAndOrdinals AtomicLongArray contains keys, and the ByteDataBuffer contains values. Each key has two components.
The high 29 bits in the key represents the ordinal. The low 35 bits represents the pointer to the start position of the byte sequence in the ByteDataBuffer. Each byte sequence is preceded by a variable-length integer (see VarInt), indicating the length of the sequence.

Constructor Summary

Constructors
Constructor and Description
`ByteArrayOrdinalMap()` Creates a byte array ordinal map with a an initial capacity of 256 elements, and a load factor of 70%.
`ByteArrayOrdinalMap(int size)` Creates a byte array ordinal map with an initial capacity of a given size rounded up to the nearest power of two, and a load factor of 70%.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`compact(ThreadSafeBitSet usedOrdinals)` Reclaim space in the byte array used in the previous cycle, but not referenced in this cycle.
`int`	`get(ByteDataBuffer serializedRepresentation)` Returns the ordinal for a previously added byte sequence.
`ByteDataBuffer`	`getByteData()`
`long`	`getDataSize()`
`int`	`getOrAssignOrdinal(ByteDataBuffer serializedRepresentation)`
`int`	`getOrAssignOrdinal(ByteDataBuffer serializedRepresentation, int preferredOrdinal)` Adds a sequence of bytes to this map.
`static int`	`getOrdinal(long pointerAndOrdinal)`
`static long`	`getPointer(long pointerAndOrdinal)`
`long`	`getPointerForData(int ordinal)`
`java.util.concurrent.atomic.AtomicLongArray`	`getPointersAndOrdinals()`
`java.util.BitSet`	`getUnusedPreviousOrdinals()`
`static boolean`	`isPointerAndOrdinalEmpty(long pointerAndOrdinal)`
`boolean`	`isReadyForAddingObjects()`
`boolean`	`isReadyForWriting()`
`int`	`maxOrdinal()`
`void`	`prepareForWrite()` Create an array mapping the ordinals to pointers, so that they can be easily looked up when writing to blob streams.
`void`	`put(ByteDataBuffer serializedRepresentation, int ordinal)` Assign a predefined ordinal to a serialized representation.
`void`	`recalculateFreeOrdinals()`
`void`	`reservePreviouslyPopulatedOrdinals(java.util.BitSet populatedOrdinals)`
`void`	`resize(int size)` Resize the ordinal map by increasing its capacity.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - ByteArrayOrdinalMap
```
public ByteArrayOrdinalMap()
```
    Creates a byte array ordinal map with a an initial capacity of 256 elements, and a load factor of 70%.
  - ByteArrayOrdinalMap
```
public ByteArrayOrdinalMap(int size)
```
    Creates a byte array ordinal map with an initial capacity of a given size rounded up to the nearest power of two, and a load factor of 70%.
- Method Detail
  - getOrAssignOrdinal
```
public int getOrAssignOrdinal(ByteDataBuffer serializedRepresentation)
```
  - getOrAssignOrdinal
```
public int getOrAssignOrdinal(ByteDataBuffer serializedRepresentation,
                              int preferredOrdinal)
```
    Adds a sequence of bytes to this map. If the sequence of bytes has previously been added to this map then its assigned ordinal is returned. If the sequence of bytes has not been added to this map then a new ordinal is assigned and returned.
    This operation is thread-safe.
    
    Parameters:
    
    serializedRepresentation - the sequence of bytes
    
    preferredOrdinal - the preferred ordinal to assign, if not already assigned to another sequence of bytes and the given sequence of bytes has not previously been added
    
    Returns:
    
    the assigned ordinal
  - put
```
public void put(ByteDataBuffer serializedRepresentation,
                int ordinal)
```
    Assign a predefined ordinal to a serialized representation.
    
    WARNING: THIS OPERATION IS NOT THREAD-SAFE.
    WARNING: THIS OPERATION WILL NOT UPDATE THE FreeOrdinalTracker.
    
    Parameters:
    
    serializedRepresentation - the serialized representation
    
    ordinal - the ordinal
  - recalculateFreeOrdinals
```
public void recalculateFreeOrdinals()
```
  - reservePreviouslyPopulatedOrdinals
```
public void reservePreviouslyPopulatedOrdinals(java.util.BitSet populatedOrdinals)
```
  - getUnusedPreviousOrdinals
```
public java.util.BitSet getUnusedPreviousOrdinals()
```
  - get
```
public int get(ByteDataBuffer serializedRepresentation)
```
    Returns the ordinal for a previously added byte sequence. If this byte sequence has not been added to the map, then -1 is returned.
    
    This is intended for use in the client-side heap-safe double snapshot load.
    
    Parameters:
    
    serializedRepresentation - the serialized representation
    
    Returns:
    
    The ordinal for this serialized representation, or -1.
  - prepareForWrite
```
public void prepareForWrite()
```
    Create an array mapping the ordinals to pointers, so that they can be easily looked up when writing to blob streams.
  - compact
```
public void compact(ThreadSafeBitSet usedOrdinals)
```
    Reclaim space in the byte array used in the previous cycle, but not referenced in this cycle.
    
    This is achieved by shifting all used byte sequences down in the byte array, then updating the key array to reflect the new pointers and exclude the removed entries. This is also where ordinals which are unused are returned to the pool.
    
    Parameters:
    
    usedOrdinals - a bit set representing the ordinals which are currently referenced by any image.
  - getPointerForData
```
public long getPointerForData(int ordinal)
```
  - isReadyForWriting
```
public boolean isReadyForWriting()
```
  - isReadyForAddingObjects
```
public boolean isReadyForAddingObjects()
```
  - getDataSize
```
public long getDataSize()
```
  - maxOrdinal
```
public int maxOrdinal()
```
  - resize
```
public void resize(int size)
```
    Resize the ordinal map by increasing its capacity.
    No action is take if the current capacity is sufficient for the given size.
    WARNING: THIS OPERATION IS NOT THREAD-SAFE.
    
    Parameters:
    
    size - the size to increase to, rounded up to the nearest power of two.
  - getByteData
```
public ByteDataBuffer getByteData()
```
  - getPointersAndOrdinals
```
public java.util.concurrent.atomic.AtomicLongArray getPointersAndOrdinals()
```
  - isPointerAndOrdinalEmpty
```
public static boolean isPointerAndOrdinalEmpty(long pointerAndOrdinal)
```
  - getPointer
```
public static long getPointer(long pointerAndOrdinal)
```
  - getOrdinal
```
public static int getOrdinal(long pointerAndOrdinal)
```

Class ByteArrayOrdinalMap

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ByteArrayOrdinalMap

ByteArrayOrdinalMap

Method Detail

getOrAssignOrdinal

getOrAssignOrdinal

put

recalculateFreeOrdinals

reservePreviouslyPopulatedOrdinals

getUnusedPreviousOrdinals

get

prepareForWrite

compact

getPointerForData

isReadyForWriting

isReadyForAddingObjects

getDataSize

maxOrdinal

resize

getByteData

getPointersAndOrdinals

isPointerAndOrdinalEmpty

getPointer

getOrdinal