IntHashFactory (Koloboke Collections 0.6 API)

Type Parameters:

F - the concrete factory type which extends this interface

All Superinterfaces:

ContainerFactory<F>, HashContainerFactory<F>

All Known Subinterfaces:

HashIntByteMapFactory, HashIntCharMapFactory, HashIntDoubleMapFactory, HashIntFloatMapFactory, HashIntIntMapFactory, HashIntLongMapFactory, HashIntObjMapFactory<V>, HashIntSetFactory, HashIntShortMapFactory
```
public interface IntHashFactory<F extends IntHashFactory<F>>
extends HashContainerFactory<F>
```
Common configuration for factories of hash containers with int keys.
Currently IntHashFactory allows to specify consecutive range of keys which could be inserted into hash container - keys domain. This is a performance hint: hash containers might, but aren't required to throw IllegalArgumentException on inserting a key out of the keys domain.
By default, all keys are allowed (keys domain is a whole range of ints, from Integer.MIN_VALUE to Integer.MAX_VALUE.
For example, map keys or elements of the set could be unique IDs, counting from 1, thus it's guaranteed that these keys are positive. Or one specific key has a special meaning in the logic of your application. When you are sure that some keys range could never be put into hash container, it is recommended to configure corresponding factory, which extends this interface, with complement of that range as keys domain (or, alternatively, with that range as keys domain complement).
It's OK to specify keys domain which include some actually impossible keys, but you shouldn't leave a single valid key out of the domain. If the set of possible (impossible) keys consist of several ranges, and/or standalone keys, it is still recommended to specify the domain to "forbid" some impossible keys. For example, if possible keys are odd numbers, you should exclude one even number, zero:
```
 factory = factory.withKeysDomainComplement(0, 0);
```

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`int`	`getLowerKeyDomainBound()` Returns lower (inclusive) bound of keys domain.
`int`	`getUpperKeyDomainBound()` Returns upper (inclusive) bound of keys domain.
`F`	`withKeysDomain(int minPossibleKey, int maxPossibleKey)` Returns a copy of this factory with keys domain set to the specified range.
`F`	`withKeysDomainComplement(int minImpossibleKey, int maxImpossibleKey)` Returns a copy of this factory with keys domain set to the complement of the specified range.

Methods inherited from interface net.openhft.koloboke.collect.hash.HashContainerFactory
getHashConfig, withHashConfig

Methods inherited from interface net.openhft.koloboke.collect.ContainerFactory
getDefaultExpectedSize, withDefaultExpectedSize

- Method Detail
  - getLowerKeyDomainBound
```
int getLowerKeyDomainBound()
```
    Returns lower (inclusive) bound of keys domain.
    Default: Integer.MIN_VALUE.
    
    Returns:
    
    lower (inclusive) bound of keys domain
  - getUpperKeyDomainBound
```
int getUpperKeyDomainBound()
```
    Returns upper (inclusive) bound of keys domain.
    Default: Integer.MAX_VALUE.
    
    Returns:
    
    upper (inclusive) bound of keys domain
  - withKeysDomain
```
F withKeysDomain(int minPossibleKey,
                 int maxPossibleKey)
```
    Returns a copy of this factory with keys domain set to the specified range.
    This is a performance hint: hash containers might, but aren't required to throw IllegalArgumentException on putting key out of the keys domain.
    Example:
```
 
 // only positive keys
 factory = factory.withKeysDomain(1, Integer.MAX_VALUE);
```
    Parameters:
    
    minPossibleKey - lower (inclusive) bound of the target keys domain
    
    maxPossibleKey - upper (inclusive) bound of the target keys domain
    
    Returns:
    
    a copy of this factory with keys domain set to the specified range
    
    Throws:
    
    IllegalArgumentException - if minPossibleKey is greater than maxPossibleKey
  - withKeysDomainComplement
```
F withKeysDomainComplement(int minImpossibleKey,
                           int maxImpossibleKey)
```
    Returns a copy of this factory with keys domain set to the complement of the specified range.
    This is a performance hint: hash containers might, but aren't required to throw IllegalArgumentException on putting key out of the keys domain.
    This method is needed to specify keys domain that include both Integer.MIN_VALUE and Integer.MAX_VALUE, but with a "hole" somewhere in between. Providing a single withKeysDomain(int, int) method for this and "ordinary" keys domain application is error-prone, because there is no way to distinguish intention (domain with a "hole") and mistakenly reordered arguments while attempting to specify "ordinary" domain.
    Example:
```
 
 // any keys except 0
 factory = factory.withKeysDomainComplement(0, 0);
```
    Parameters:
    
    minImpossibleKey - upper (exclusive) bound of the target keys domain
    
    maxImpossibleKey - lower (exclusive) bound of the target keys domain
    
    Returns:
    
    a copy of this factory with keys domain set to the complement of the specified range
    
    Throws:
    
    IllegalArgumentException - if minImpossibleKey is greater than maxImpossibleKey

Interface IntHashFactory<F extends IntHashFactory<F>>

Method Summary

Methods inherited from interface net.openhft.koloboke.collect.hash.HashContainerFactory

Methods inherited from interface net.openhft.koloboke.collect.ContainerFactory

Method Detail

getLowerKeyDomainBound

getUpperKeyDomainBound

withKeysDomain

withKeysDomainComplement