Package mssql.googlecode.concurrentlinkedhashmap

## Class ConcurrentLinkedHashMap.Builder<K,​V>

- java.lang.Object
- - mssql.googlecode.concurrentlinkedhashmap.ConcurrentLinkedHashMap.Builder<K,​V>

Enclosing class:
  ConcurrentLinkedHashMap<K,​V>

    public static final class ConcurrentLinkedHashMap.Builder<K,​V>
    extends java.lang.Object

A builder that creates `ConcurrentLinkedHashMap` instances. It provides a flexible approach for constructing customized instances with a named parameter syntax. It can be used in the following manner:

     ConcurrentMap<Vertex, Set<G>> graph = new Builder<Vertex, Set<G>>()
         .maximumWeightedCapacity(5000)
         .weigher(Weighers.<G>set())
         .build();

### Constructor Summary

Constructors
`Builder()`

### Method Summary

All Methods Instance Methods Concrete Methods
`ConcurrentLinkedHashMap<K,​V>` `build()` Creates a new `ConcurrentLinkedHashMap` instance.
`ConcurrentLinkedHashMap.Builder<K,​V>` `concurrencyLevel​(int concurrencyLevel)` Specifies the estimated number of concurrently updating threads.
`ConcurrentLinkedHashMap.Builder<K,​V>` `initialCapacity​(int initialCapacity)` Specifies the initial capacity of the hash table (default `16`).
`ConcurrentLinkedHashMap.Builder<K,​V>` `listener​(EvictionListener<K,​V> listener)` Specifies an optional listener that is registered for notification when an entry is evicted.
`ConcurrentLinkedHashMap.Builder<K,​V>` `maximumWeightedCapacity​(long capacity)` Specifies the maximum weighted capacity to coerce the map to and may exceed it temporarily.
`ConcurrentLinkedHashMap.Builder<K,​V>` `weigher​(EntryWeigher<? super K,​? super V> weigher)` Specifies an algorithm to determine how many the units of capacity an entry consumes.
`ConcurrentLinkedHashMap.Builder<K,​V>` `weigher​(Weigher<? super V> weigher)` Specifies an algorithm to determine how many the units of capacity a value consumes.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Constructor Detail

#### Builder

    public Builder()

### Method Detail

#### initialCapacity

    public ConcurrentLinkedHashMap.Builder<K,​V> initialCapacity​(int initialCapacity)

Specifies the initial capacity of the hash table (default `16`). This is the number of key-value pairs that the hash table can hold before a resize operation is required.

Parameters:
  `initialCapacity` - the initial capacity used to size the hash table to accommodate this many entries.
Returns:
  Builder
Throws:
  `java.lang.IllegalArgumentException` - if the initialCapacity is negative

#### maximumWeightedCapacity

    public ConcurrentLinkedHashMap.Builder<K,​V> maximumWeightedCapacity​(long capacity)

Specifies the maximum weighted capacity to coerce the map to and may exceed it temporarily.

Parameters:
  `capacity` - the weighted threshold to bound the map by
Returns:
  Builder
Throws:
  `java.lang.IllegalArgumentException` - if the maximumWeightedCapacity is negative

#### concurrencyLevel

    public ConcurrentLinkedHashMap.Builder<K,​V> concurrencyLevel​(int concurrencyLevel)

Specifies the estimated number of concurrently updating threads. The implementation performs internal sizing to try to accommodate this many threads (default `16`).

Parameters:
  `concurrencyLevel` - the estimated number of concurrently updating threads
Returns:
  Builder
Throws:
  `java.lang.IllegalArgumentException` - if the concurrencyLevel is less than or equal to zero

#### listener

    public ConcurrentLinkedHashMap.Builder<K,​V> listener​(EvictionListener<K,​V> listener)

Specifies an optional listener that is registered for notification when an entry is evicted.

Parameters:
  `listener` - the object to forward evicted entries to
Returns:
  Builder
Throws:
  `java.lang.NullPointerException` - if the listener is null

#### weigher

    public ConcurrentLinkedHashMap.Builder<K,​V> weigher​(Weigher<? super V> weigher)

Specifies an algorithm to determine how many the units of capacity a value consumes. The default algorithm bounds the map by the number of key-value pairs by giving each entry a weight of `1`.

Parameters:
  `weigher` - the algorithm to determine a value's weight
Returns:
  Builder
Throws:
  `java.lang.NullPointerException` - if the weigher is null

#### weigher

    public ConcurrentLinkedHashMap.Builder<K,​V> weigher​(EntryWeigher<? super K,​? super V> weigher)

Specifies an algorithm to determine how many the units of capacity an entry consumes. The default algorithm bounds the map by the number of key-value pairs by giving each entry a weight of `1`.

Parameters:
  `weigher` - the algorithm to determine a entry's weight
Returns:
  Builder
Throws:
  `java.lang.NullPointerException` - if the weigher is null

#### build

    public ConcurrentLinkedHashMap<K,​V> build()

Creates a new `ConcurrentLinkedHashMap` instance.

Returns:
  ConcurrentLinkedHashMap
Throws:
  `java.lang.IllegalStateException` - if the maximum weighted capacity was not set