SharedKeyMap (Test 0.0.6 API)

java.lang.Object
- java.util.AbstractMap<K,V>
- - com.force.i18n.settings.SharedKeyMap<K,V>

All Implemented Interfaces:

Serializable, Map<K,V>
```
public class SharedKeyMap<K,V>
extends AbstractMap<K,V>
implements Serializable
```
SharedKeyMap is an implementation of the Map interface where many SharedKeyMap instances share a single copy of their key mappings. This is useful if you have many maps that all have the same (or nearly the same) keys, because you don't have to store the keys over and over. Because SharedKeyMaps only make sense when there are multiple maps in play, the only way to create one is with the static factory methods createSharedKeyMaps and createEmptySharedKeyMaps, which create a List of SharedKeyMaps that all share the same keys. Internally, each SharedKeyMap points to a single Map that maps keys to integer indices. Then each SharedKeyMap has its own ArrayList that contains its values, indexed by the indices mentioned above. Removing from an individual SharedKeyMap doesn't affect the shared map, but adding to an individual SharedKeyMap with a key that wasn't in the shared map will add that key to the shared map.

Author:

shansma

See Also:

Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from class java.util.AbstractMap
  AbstractMap.SimpleEntry<K,V>, AbstractMap.SimpleImmutableEntry<K,V>
- Nested classes/interfaces inherited from interface java.util.Map
  Map.Entry<K,V>

Constructor Summary

Constructors
Constructor and Description
`SharedKeyMap()` Creates an empty, isolated SharedKeyMap.
`SharedKeyMap(int initialValueCapacity)` Creates an empty, isolated SharedKeyMap, with control over the initial size of the values array.
`SharedKeyMap(Map<K,Integer> keyToIndex, int initialValueCapacity)` Creates an empty, isolated SharedKeyMap, with control over the key-to-index value map and also initial size of the values array.
`SharedKeyMap(SharedKeyMap<K,? extends V> map)` Creates a new shared key map that shares the keymap of map.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clear()` Clears out the values in this instance of a SharedKeyMap; does not affect the contents of the key-to-index map.
`boolean`	`containsKey(Object key)`
`boolean`	`containsValue(Object value)`
`static <K,V> List<SharedKeyMap<K,V>>`	`createEmptySharedKeyMaps(int numberOfMaps)` Creates a list of empty SharedKeyMaps that all share a single (empty) key map.
`static <K,V> List<SharedKeyMap<K,V>>`	`createEmptySharedKeyMaps(int numberOfMaps, SharedKeyMap<K,V> map)` Creates a list of empty SharedKeyMaps that all use the key map of the specified SharedKeyMap.
`static <K,V> List<SharedKeyMap<K,V>>`	`createEmptySharedKeyMaps(List<K> keys, int numberOfMaps)` Creates a list of empty SharedKeyMaps that all use the specified keys.
`static <K,V> List<SharedKeyMap<K,V>>`	`createSharedKeyMaps(List<Map<K,V>> maps)` Takes a list of Maps and returns a list of SharedKeyMaps with the same mappings and values.
`static <K,V> List<SharedKeyMap<K,V>>`	`createSharedKeyMaps(List<Map<K,V>> maps, boolean removeFromList)` Takes a list of Maps and returns a list of SharedKeyMaps with the same mappings and values.
`Set<Map.Entry<K,V>>`	`entrySet()` The getKey function on the MapEntries returned by this iterator takes O(keys) time, so don't call it if you can avoid it.
`V`	`get(Object key)`
`int`	`keyMapSize()` Returns the number of entries in the keymap.
`Set<K>`	`keySet()`
`V`	`put(K key, V value)`
`V`	`remove(Object key)`
`int`	`size()`
`void`	`trimToSize()`

Methods inherited from class java.util.AbstractMap
clone, equals, hashCode, isEmpty, putAll, toString, values

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.Map
compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, putIfAbsent, remove, replace, replace, replaceAll

- Constructor Detail
  - SharedKeyMap
```
public SharedKeyMap(SharedKeyMap<K,? extends V> map)
```
    Creates a new shared key map that shares the keymap of map.
  - SharedKeyMap
```
public SharedKeyMap()
```
    Creates an empty, isolated SharedKeyMap.
  - SharedKeyMap
```
public SharedKeyMap(int initialValueCapacity)
```
    Creates an empty, isolated SharedKeyMap, with control over the initial size of the values array. This is useful when you have a SharedKeyMap that you use as the canonical version to "clone" for other SharedKeyMaps and you want to save the overhead of the unnecessary value arrays that would remain empty.
    
    Parameters:
    
    initialValueCapacity - if this is non-negative, then its used as the initial size for the values array. If its negative, then this SharedKeyMap cannot have any values stored in it.
  - SharedKeyMap
```
public SharedKeyMap(Map<K,Integer> keyToIndex,
                    int initialValueCapacity)
```
    Creates an empty, isolated SharedKeyMap, with control over the key-to-index value map and also initial size of the values array. This is useful when you have a SharedKeyMap that you use as the canonical version to "clone" for other SharedKeyMaps and you want to save the overhead of the unnecessary value arrays that would remain empty.
    
    Parameters:
    
    keyToIndex - maps keys to their index in the values array. This structure is shared across threads.
    
    initialValueCapacity - if this is non-negative, then its used as the initial size for the values array. If its negative, then this SharedKeyMap cannot have any values stored in it.
- Method Detail
  - createSharedKeyMaps
```
public static <K,V> List<SharedKeyMap<K,V>> createSharedKeyMaps(List<Map<K,V>> maps)
```
    Takes a list of Maps and returns a list of SharedKeyMaps with the same mappings and values.
    
    Parameters:
    
    maps - - the maps to re-create as SharedKeyMaps
  - createSharedKeyMaps
```
public static <K,V> List<SharedKeyMap<K,V>> createSharedKeyMaps(List<Map<K,V>> maps,
                                                                boolean removeFromList)
```
    Takes a list of Maps and returns a list of SharedKeyMaps with the same mappings and values.
    
    Parameters:
    
    maps - - the maps to re-create as SharedKeyMaps
    
    removeFromList - - remove the passed-in maps from the list as they are processed, so they can be garbage collected.
  - createEmptySharedKeyMaps
```
public static <K,V> List<SharedKeyMap<K,V>> createEmptySharedKeyMaps(List<K> keys,
                                                                     int numberOfMaps)
```
    Creates a list of empty SharedKeyMaps that all use the specified keys. If you know ahead of time what the keys in your maps will (likely) be, but don't yet have the maps created, you can call this function and then use the maps it returns as you would use normal maps.
    
    Parameters:
    
    keys - - the keys that all your maps will (likely) use
    
    numberOfMaps - - the number of maps this function will create for you
  - createEmptySharedKeyMaps
```
public static <K,V> List<SharedKeyMap<K,V>> createEmptySharedKeyMaps(int numberOfMaps)
```
    Creates a list of empty SharedKeyMaps that all share a single (empty) key map.
    
    Parameters:
    
    numberOfMaps - - the number of maps this function will create for you
  - createEmptySharedKeyMaps
```
public static <K,V> List<SharedKeyMap<K,V>> createEmptySharedKeyMaps(int numberOfMaps,
                                                                     SharedKeyMap<K,V> map)
```
    Creates a list of empty SharedKeyMaps that all use the key map of the specified SharedKeyMap.
    
    Parameters:
    
    numberOfMaps - - the number of maps this function will create for you
  - size
```
public int size()
```
    Specified by:
    
    size in interface Map<K,V>
    
    Overrides:
    
    size in class AbstractMap<K,V>
  - trimToSize
```
public void trimToSize()
```
  - containsKey
```
public boolean containsKey(Object key)
```
    Specified by:
    
    containsKey in interface Map<K,V>
    
    Overrides:
    
    containsKey in class AbstractMap<K,V>
  - containsValue
```
public boolean containsValue(Object value)
```
    Specified by:
    
    containsValue in interface Map<K,V>
    
    Overrides:
    
    containsValue in class AbstractMap<K,V>
  - get
```
public V get(Object key)
```
    Specified by:
    
    get in interface Map<K,V>
    
    Overrides:
    
    get in class AbstractMap<K,V>
  - put
```
public V put(K key,
             V value)
```
    Specified by:
    
    put in interface Map<K,V>
    
    Overrides:
    
    put in class AbstractMap<K,V>
  - remove
```
public V remove(Object key)
```
    Specified by:
    
    remove in interface Map<K,V>
    
    Overrides:
    
    remove in class AbstractMap<K,V>
  - clear
```
public void clear()
```
    Clears out the values in this instance of a SharedKeyMap; does not affect the contents of the key-to-index map.
    
    Specified by:
    
    clear in interface Map<K,V>
    
    Overrides:
    
    clear in class AbstractMap<K,V>
  - keySet
```
public Set<K> keySet()
```
    Specified by:
    
    keySet in interface Map<K,V>
    
    Overrides:
    
    keySet in class AbstractMap<K,V>
  - entrySet
```
public Set<Map.Entry<K,V>> entrySet()
```
    The getKey function on the MapEntries returned by this iterator takes O(keys) time, so don't call it if you can avoid it.
    
    Specified by:
    
    entrySet in interface Map<K,V>
    
    Specified by:
    
    entrySet in class AbstractMap<K,V>
  - keyMapSize
```
public int keyMapSize()
```
    Returns the number of entries in the keymap. This isn't something you should generally care about, but if you're the curious type, here it is. It's also useful if you're serializing SharedKeyMaps one by one -- since the keymap is always appended to, and entries are never modified or removed, keyMapSize() will change whenever the contents of the keymap have changed (and thus need to be re-serialized).

Class SharedKeyMap<K,V>

Nested Class Summary

Nested classes/interfaces inherited from class java.util.AbstractMap

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

Constructor Summary

Method Summary

Methods inherited from class java.util.AbstractMap

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Map

Constructor Detail

SharedKeyMap

SharedKeyMap

SharedKeyMap

SharedKeyMap

Method Detail

createSharedKeyMaps

createSharedKeyMaps

createEmptySharedKeyMaps

createEmptySharedKeyMaps

createEmptySharedKeyMaps

size

trimToSize

containsKey

containsValue

get

put

remove

clear

keySet

entrySet

keyMapSize