ConcurrentHashCounter (Stanford JavaNLP API)

java.lang.Object
- edu.stanford.nlp.util.concurrent.ConcurrentHashCounter<E>

Type Parameters:

E - Element type to store

All Implemented Interfaces:

Counter<E>, PrettyLoggable, java.io.Serializable, java.lang.Iterable<E>
```
public class ConcurrentHashCounter<E>
extends java.lang.Object
implements java.io.Serializable, Counter<E>, java.lang.Iterable<E>
```
A threadsafe counter implemented as a lightweight wrapper around a ConcurrentHashMap.

Author:

Spence Green

See Also:

Serialized Form

Constructor Summary

Constructors
Constructor and Description

ConcurrentHashCounter()

ConcurrentHashCounter(int initialCapacity)

Constructors
Constructor and Description
`ConcurrentHashCounter()`
`ConcurrentHashCounter(int initialCapacity)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addAll(Counter<E> counter)` Adds the counts in the given Counter to the counts in this Counter.
`void`	`clear()` Removes all entries from the counter.
`boolean`	`containsKey(E key)` Returns whether a Counter contains a key.
`double`	`decrementCount(E key)` Decrements the count for this key by 1.0.
`double`	`decrementCount(E key, double value)` Decrements the count for this key by the given value.
`double`	`defaultReturnValue()` Returns the default return value.
`java.util.Set<java.util.Map.Entry<E,java.lang.Double>>`	`entrySet()` Returns a view of the entries in this counter.
`boolean`	`equals(java.lang.Object o)`
`double`	`getCount(java.lang.Object key)` Returns the count for this key as a double.
`Factory<Counter<E>>`	`getFactory()` Returns a factory that can create new instances of this kind of Counter.
`int`	`hashCode()` Returns a hashCode which is the underlying Map's hashCode.
`double`	`incrementCount(E key)` Increments the count for this key by 1.0.
`double`	`incrementCount(E key, double value)` Increments the count for the given key by the given value.
`java.util.Iterator<E>`	`iterator()`
`java.util.Set<E>`	`keySet()` Returns the Set of keys in this counter.
`double`	`logIncrementCount(E key, double value)` Increments the count stored in log space for this key by the given log-transformed value.
`void`	`prettyLog(Redwood.RedwoodChannels channels, java.lang.String description)` Pretty logs the current object to specific Redwood channels.
`double`	`remove(E key)` Removes the given key and its associated value from this Counter.
`void`	`setCount(E key, double value)` Sets the count for the given key to be the given value.
`void`	`setDefaultReturnValue(double value)` Sets the default return value.
`int`	`size()` Returns the number of entries stored in this counter.
`java.lang.String`	`toString()` Returns a String representation of the Counter, as formatted by the underlying Map.
`double`	`totalCount()` Computes the total of all counts in this counter, and returns it as a double.
`java.util.Collection<java.lang.Double>`	`values()` Returns a copy of the values currently in this counter.

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

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Constructor Detail
  - ConcurrentHashCounter
```
public ConcurrentHashCounter()
```
  - ConcurrentHashCounter
```
public ConcurrentHashCounter(int initialCapacity)
```
- Method Detail
  - iterator
```
public java.util.Iterator<E> iterator()
```
    Specified by:
    
    iterator in interface java.lang.Iterable<E>
  - getFactory
```
public Factory<Counter<E>> getFactory()
```
    Description copied from interface: Counter
    
    Returns a factory that can create new instances of this kind of Counter.
    
    Specified by:
    
    getFactory in interface Counter<E>
    
    Returns:
    
    A factory that can create new instances of this kind of Counter.
  - setDefaultReturnValue
```
public void setDefaultReturnValue(double value)
```
    Description copied from interface: Counter
    
    Sets the default return value. This value is returned when you get the value for keys that are not in the Counter. It is zero by default, but can sometimes usefully by set to other values like Double.NaN or Double.NEGATIVE_INFINITY.
    
    Specified by:
    
    setDefaultReturnValue in interface Counter<E>
    
    Parameters:
    
    value - The default value
  - defaultReturnValue
```
public double defaultReturnValue()
```
    Description copied from interface: Counter
    
    Returns the default return value.
    
    Specified by:
    
    defaultReturnValue in interface Counter<E>
    
    Returns:
    
    The default return value.
  - getCount
```
public double getCount(java.lang.Object key)
```
    Description copied from interface: Counter
    
    Returns the count for this key as a double. This is the defaultReturnValue (0.0, if it hasn't been set) if the key hasn't previously been seen.
    
    Specified by:
    
    getCount in interface Counter<E>
    
    Parameters:
    
    key - The key
    
    Returns:
    
    The count
  - setCount
```
public void setCount(E key,
                     double value)
```
    Description copied from interface: Counter
    
    Sets the count for the given key to be the given value. This will replace any existing count for the key. To add to a count instead of replacing it, use Counter.incrementCount(Object,double).
    
    Specified by:
    
    setCount in interface Counter<E>
    
    Parameters:
    
    key - The key
    
    value - The count
  - incrementCount
```
public double incrementCount(E key,
                             double value)
```
    Description copied from interface: Counter
    
    Increments the count for the given key by the given value. If the key hasn't been seen before, it is assumed to have count 0.0, and thus this method will set its count to the given amount. Note that this is true regardless of the setting of defaultReturnValue. Negative increments are equivalent to calling decrementCount. To more conveniently increment the count by 1.0, use Counter.incrementCount(Object). To set a count to a specific value instead of incrementing it, use Counter.setCount(Object,double).
    
    Specified by:
    
    incrementCount in interface Counter<E>
    
    Parameters:
    
    key - The key to increment
    
    value - The amount to increment it by
    
    Returns:
    
    The value associated with they key, post-increment.
  - incrementCount
```
public double incrementCount(E key)
```
    Description copied from interface: Counter
    
    Increments the count for this key by 1.0. If the key hasn't been seen before, it is assumed to have count 0.0, and thus this method will set its count to 1.0. Note that this is true regardless of the setting of defaultReturnValue. To increment the count by a value other than 1.0, use Counter.incrementCount(Object,double). To set a count to a specific value instead of incrementing it, use Counter.setCount(Object,double).
    
    Specified by:
    
    incrementCount in interface Counter<E>
    
    Parameters:
    
    key - The key to increment by 1.0
    
    Returns:
    
    The value associated with they key, post-increment.
  - decrementCount
```
public double decrementCount(E key,
                             double value)
```
    Description copied from interface: Counter
    
    Decrements the count for this key by the given value. If the key hasn't been seen before, it is assumed to have count 0.0, and thus this method will set its count to the negative of the given amount. Note that this is true regardless of the setting of defaultReturnValue. Negative increments are equivalent to calling incrementCount. To more conveniently decrement the count by 1.0, use Counter.decrementCount(Object). To set a count to a specific value instead of decrementing it, use Counter.setCount(Object,double).
    
    Specified by:
    
    decrementCount in interface Counter<E>
    
    Parameters:
    
    key - The key to decrement
    
    value - The amount to decrement it by
    
    Returns:
    
    The value associated with they key, post-decrement.
  - decrementCount
```
public double decrementCount(E key)
```
    Description copied from interface: Counter
    
    Decrements the count for this key by 1.0. If the key hasn't been seen before, it is assumed to have count 0.0, and thus this method will set its count to -1.0. Note that this is true regardless of the setting of defaultReturnValue. To decrement the count by a value other than 1.0, use Counter.decrementCount(Object,double). To set a count to a specific value instead of decrementing it, use Counter.setCount(Object,double).
    
    Specified by:
    
    decrementCount in interface Counter<E>
    
    Parameters:
    
    key - The key to decrement by 1.0
    
    Returns:
    
    The value of associated with they key, post-decrement.
  - logIncrementCount
```
public double logIncrementCount(E key,
                                double value)
```
    Description copied from interface: Counter
    
    Increments the count stored in log space for this key by the given log-transformed value. If the current count for the key is v1, and you call logIncrementCount with a value of v2, then the new value will be log(e^v1 + e^v2). If the key hasn't been seen before, it is assumed to have count Double.NEGATIVE_INFINITY, and thus this method will set its count to the given amount. Note that this is true regardless of the setting of defaultReturnValue. To set a count to a specific value instead of incrementing it, you need to first take the log yourself and then to call Counter.setCount(Object,double).
    
    Specified by:
    
    logIncrementCount in interface Counter<E>
    
    Parameters:
    
    key - The key to increment
    
    value - The amount to increment it by, in log space
    
    Returns:
    
    The value associated with they key, post-increment, in log space
  - addAll
```
public void addAll(Counter<E> counter)
```
    Description copied from interface: Counter
    
    Adds the counts in the given Counter to the counts in this Counter. This is identical in effect to calling Counters.addInPlace(this, counter).
    
    Specified by:
    
    addAll in interface Counter<E>
    
    Parameters:
    
    counter - The Counter whose counts will be added. For each key in counter, if it is not in this, then it will be added with value counter.getCount(key). Otherwise, it will have value this.getCount(key) + counter.getCount(key).
  - remove
```
public double remove(E key)
```
    Description copied from interface: Counter
    
    Removes the given key and its associated value from this Counter. Its count will now be returned as the defaultReturnValue and it will no longer be considered previously seen. If a key not contained in the Counter is given, no action is performed on the Counter and the defaultValue is returned. This behavior echoes that of HashMap, but differs since a HashMap returns a Double (rather than double) and thus returns null if a key is not present. Any future revisions of Counter should preserve the ability to "remove" a key that is not present in the Counter.
    
    Specified by:
    
    remove in interface Counter<E>
    
    Parameters:
    
    key - The key
    
    Returns:
    
    The value removed from the map or the default value if no count was associated with that key.
  - containsKey
```
public boolean containsKey(E key)
```
    Description copied from interface: Counter
    
    Returns whether a Counter contains a key.
    
    Specified by:
    
    containsKey in interface Counter<E>
    
    Parameters:
    
    key - The key
    
    Returns:
    
    true iff key is a key in this Counter.
  - keySet
```
public java.util.Set<E> keySet()
```
    Description copied from interface: Counter
    
    Returns the Set of keys in this counter.
    
    Specified by:
    
    keySet in interface Counter<E>
    
    Returns:
    
    The Set of keys in this counter.
  - values
```
public java.util.Collection<java.lang.Double> values()
```
    Description copied from interface: Counter
    
    Returns a copy of the values currently in this counter. (You should regard this Collection as read-only for forward compatibility; at present implementations differ on how they respond to attempts to change this Collection.)
    
    Specified by:
    
    values in interface Counter<E>
    
    Returns:
    
    A copy of the values currently in this counter.
  - entrySet
```
public java.util.Set<java.util.Map.Entry<E,java.lang.Double>> entrySet()
```
    Description copied from interface: Counter
    
    Returns a view of the entries in this counter. The values can be safely modified with setValue().
    
    Specified by:
    
    entrySet in interface Counter<E>
    
    Returns:
    
    A view of the entries in this counter
  - clear
```
public void clear()
```
    Description copied from interface: Counter
    
    Removes all entries from the counter.
    
    Specified by:
    
    clear in interface Counter<E>
  - size
```
public int size()
```
    Description copied from interface: Counter
    
    Returns the number of entries stored in this counter.
    
    Specified by:
    
    size in interface Counter<E>
    
    Returns:
    
    The number of entries in this counter.
  - totalCount
```
public double totalCount()
```
    Description copied from interface: Counter
    
    Computes the total of all counts in this counter, and returns it as a double. (Existing implementations cache this value, so that this operation is cheap.)
    
    Specified by:
    
    totalCount in interface Counter<E>
    
    Returns:
    
    The total (arithmetic sum) of all counts in this counter.
  - equals
```
public boolean equals(java.lang.Object o)
```
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Returns a hashCode which is the underlying Map's hashCode.
    
    Overrides:
    
    hashCode in class java.lang.Object
    
    Returns:
    
    A hashCode.
  - toString
```
public java.lang.String toString()
```
    Returns a String representation of the Counter, as formatted by the underlying Map.
    
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    
    A String representation of the Counter.
  - prettyLog
```
public void prettyLog(Redwood.RedwoodChannels channels,
                      java.lang.String description)
```
    Description copied from interface: PrettyLoggable
    
    Pretty logs the current object to specific Redwood channels.
    
    Specified by:
    
    prettyLog in interface PrettyLoggable
    
    Parameters:
    
    channels - the channels which should be logged to -- all logging calls should use logging methods on the channels (e.g. channels.log(), etc.)
    
    description - The description of the object. It will potentially identify the object's functional role or (failing that) its class. This is typically used as a track name surrounding the contents of this object.

Class ConcurrentHashCounter<E>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Constructor Detail

ConcurrentHashCounter

ConcurrentHashCounter

Method Detail

iterator

getFactory

setDefaultReturnValue

defaultReturnValue

getCount

setCount

incrementCount

incrementCount

decrementCount

decrementCount

logIncrementCount

addAll

remove

containsKey

keySet

values

entrySet

clear

size

totalCount

equals

hashCode

toString

prettyLog