Package org.multiverse.collections

## Class NaiveTxnHashMap<K,​V>

- java.lang.Object
- - org.multiverse.collections.AbstractTxnMap<K,​V>
  - - org.multiverse.collections.NaiveTxnHashMap<K,​V>

- All Implemented Interfaces:
    `Map<K,​V>`, `TxnMap<K,​V>`

      public final class NaiveTxnHashMap<K,​V>
      extends AbstractTxnMap<K,​V>

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from interface java.util.Map

      `Map.Entry<K extends Object,​V extends Object>`

  - ### Field Summary

    - ### Fields inherited from class org.multiverse.collections.AbstractTxnMap

      `defaultRefFactory, stm`

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `NaiveTxnHashMap​(Stm stm)` |

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | `clear​(Txn tx)` | Removes all of the mappings from this map (optional operation).
    `boolean` | `containsKey​(Txn tx, Object key)` | Returns `true` if this map contains a mapping for the specified key.
    `boolean` | `containsValue​(Txn tx, Object value)` | Returns `true` if this map maps one or more keys to the specified value.
    `TxnSet<Map.Entry<K,​V>>` | `entrySet​(Txn tx)` | Returns a `TxnSet` view of the mappings contained in this map.
    `V` | `get​(Txn tx, Object key)` | Returns the value to which the specified key is mapped, or `null` if this map contains no mapping for the key.
    `float` | `getLoadFactor()` |
    `TxnSet<K>` | `keySet​(Txn tx)` | Returns a `TxnSet` view of the keys contained in this map.
    `V` | `put​(Txn tx, K key, V value)` | Associates the specified value with the specified key in this map (optional operation).
    `V` | `remove​(Txn tx, Object key)` | Removes the mapping for a key from this map if it is present (optional operation).
    `int` | `size​(Txn tx)` | Returns the number of key-value mappings in this map.
    `String` | `toString​(Txn tx)` |
    `TxnCollection<V>` | `values​(Txn tx)` | Returns a `TxnCollection` view of the values contained in this map.

    - ### Methods inherited from class org.multiverse.collections.AbstractTxnMap

      `clear, containsKey, containsValue, entrySet, get, getStm, isEmpty, isEmpty, keySet, put, putAll, putAll, remove, size, toString, values`

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

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

    - ### Methods inherited from interface java.util.Map

      `compute, computeIfAbsent, computeIfPresent, equals, forEach, getOrDefault, hashCode, merge, putIfAbsent, remove, replace, replace, replaceAll`

- - ### Constructor Detail

    - #### NaiveTxnHashMap

          public NaiveTxnHashMap​(Stm stm)

  - ### Method Detail

    - #### getLoadFactor

          public float getLoadFactor()

    - #### clear

          public void clear​(Txn tx)

      Description copied from interface: `TxnMap`
      Removes all of the mappings from this map (optional operation). The map will be empty after this call returns.

    - #### size

          public int size​(Txn tx)

      Description copied from interface: `TxnMap`
      Returns the number of key-value mappings in this map. If the map contains more than `Integer.MAX_VALUE` elements, returns `Integer.MAX_VALUE`.
      Returns:
        the number of key-value mappings in this map

    - #### get

          public V get​(Txn tx,
                       Object key)

      Description copied from interface: `TxnMap`
      Returns the value to which the specified key is mapped, or `null` if this map contains no mapping for the key.

      More formally, if this map contains a mapping from a key `k` to a value `v` such that `(key==null ? k==null : key.equals(k))`, then this method returns `v`; otherwise it returns `null`. (There can be at most one such mapping.)

      If this map permits null values, then a return value of `null` does not necessarily indicate that the map contains no mapping for the key; it's also possible that the map explicitly maps the key to `null`. The `containsKey` operation may be used to distinguish these two cases.

        `key` - the key whose associated value is to be returned
      Returns:
        the value to which the specified key is mapped, or `null` if this map contains no mapping for the key

    - #### put

          public V put​(Txn tx,
                       K key,
                       V value)

      Description copied from interface: `TxnMap`
      Associates the specified value with the specified key in this map (optional operation). If the map previously contained a mapping for the key, the old value is replaced by the specified value. (A map `m` is said to contain a mapping for a key `k` if and only if `m.containsKey(k)` would return `true`.)
        `key` - key with which the specified value is to be associated
        `value` - value to be associated with the specified key
      Returns:
        the previous value associated with `key`, or `null` if there was no mapping for `key`. (A `null` return can also indicate that the map previously associated `null` with `key`, if the implementation supports `null` values.)

    - #### remove

          public V remove​(Txn tx,
                          Object key)

      Description copied from interface: `TxnMap`
      Removes the mapping for a key from this map if it is present (optional operation). More formally, if this map contains a mapping from key `k` to value `v` such that `(key==null ? k==null : key.equals(k))`, that mapping is removed. (The map can contain at most one such mapping.)

      Returns the value to which this map previously associated the key, or `null` if the map contained no mapping for the key.

      If this map permits null values, then a return value of `null` does not necessarily indicate that the map contained no mapping for the key; it's also possible that the map explicitly mapped the key to `null`.

      The map will not contain a mapping for the specified key once the call returns.

        `key` - key whose mapping is to be removed from the map
      Returns:
        the previous value associated with `key`, or `null` if there was no mapping for `key`.

    - #### toString

          public String toString​(Txn tx)

    - #### entrySet

          public TxnSet<Map.Entry<K,​V>> entrySet​(Txn tx)

      Description copied from interface: `TxnMap`
      Returns a `TxnSet` view of the mappings contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own `remove` operation, or through the `setValue` operation on a map entry returned by the iterator) the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the `Iterator.remove`, `Set.remove`, `removeAll`, `retainAll` and `clear` operations. It does not support the `add` or `addAll` operations.
      Returns:
        a set view of the mappings contained in this map

    - #### keySet

          public TxnSet<K> keySet​(Txn tx)

      Description copied from interface: `TxnMap`
      Returns a `TxnSet` view of the keys contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own `remove` operation), the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the `Iterator.remove`, `Set.remove`, `removeAll`, `retainAll`, and `clear` operations. It does not support the `add` or `addAll` operations.
      Returns:
        a set view of the keys contained in this map

    - #### containsKey

          public boolean containsKey​(Txn tx,
                                     Object key)

      Description copied from interface: `TxnMap`
      Returns `true` if this map contains a mapping for the specified key. More formally, returns `true` if and only if this map contains a mapping for a key `k` such that `(key==null ? k==null : key.equals(k))`. (There can be at most one such mapping.)
        `key` - key whose presence in this map is to be tested
      Returns:
        `true` if this map contains a mapping for the specified key

    - #### containsValue

          public boolean containsValue​(Txn tx,
                                       Object value)

      Description copied from interface: `TxnMap`
      Returns `true` if this map maps one or more keys to the specified value. More formally, returns `true` if and only if this map contains at least one mapping to a value `v` such that `(value==null ? v==null : value.equals(v))`. This operation will probably require time linear in the map size for most implementations of the `Map` interface.
        `value` - value whose presence in this map is to be tested
      Returns:
        `true` if this map maps one or more keys to the specified value

    - #### values

          public TxnCollection<V> values​(Txn tx)

      Description copied from interface: `TxnMap`
      Returns a `TxnCollection` view of the values contained in this map. The collection is backed by the map, so changes to the map are reflected in the collection, and vice-versa. If the map is modified while an iteration over the collection is in progress (except through the iterator's own `remove` operation), the results of the iteration are undefined. The collection supports element removal, which removes the corresponding mapping from the map, via the `Iterator.remove`, `Collection.remove`, `removeAll`, `retainAll` and `clear` operations. It does not support the `add` or `addAll` operations.
      Returns:
        a collection view of the values contained in this map