com.antelmann.math
Class DataMap<T>

java.lang.Object
  com.antelmann.math.DataMap<T>

Type Parameters:

T - the category type that is supported by this data map

All Implemented Interfaces:

Serializable, Cloneable

public class DataMap<T>
extends Object
implements Serializable, Cloneable

allows to easily collect data based on a category and a number

Since:

11.07.2009, 22:15:10

Author:

Holger Antelmann

See Also:

CounterMap, DataMatrix, Serialized Form

Nested Class Summary

static class

DataMap.SnapshotModel

Constructor Summary

DataMap()

Method Summary

void	add(T category, DataPoint x)
void	add(T category, Number n)
void	addAll(DataMap<T> data)
protected void	checkSize()
void	clear()
DataMap<T>	clone()
boolean	containsKey(T key)
Set<T>	getCategories()
DataMap.SnapshotModel	getSnapshotModel()
ArrayList<T>	getSortedKeys() uses the natural order or - if not applicable - a UniversalComparator
ArrayList<T>	getSortedKeys(Comparator<? super T> comp) provides a sorted snapshot of the keys in this data map
DataPoint	getValue(T category)
DataPoint	getValueForAll()
Map<T,DataPoint>	getView()
boolean	isEmpty()
void	limitSize(int limit) uses no comparator
void	limitSize(int limit, Comparator<DataPoint> dpComparator) uses the given limit as both: upper and lower limit
void	limitSize(int upperLimit, int lowerLimit, Comparator<DataPoint> dpComparator) allows to limit this data map to a given number of keys.
void	purge(int limit, Comparator<DataPoint> comparator)
int	size()

Methods inherited from class java.lang.Object

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

Constructor Detail

DataMap

public DataMap()

Method Detail

clone

public DataMap<T> clone()
                 throws CloneNotSupportedException

Overrides:

clone in class Object

Throws:

CloneNotSupportedException

add

public void add(T category,
                Number n)

add

public void add(T category,
                DataPoint x)

addAll

public void addAll(DataMap<T> data)

limitSize

public void limitSize(int limit)

uses no comparator

limitSize

public void limitSize(int limit,
                      Comparator<DataPoint> dpComparator)

uses the given limit as both: upper and lower limit

limitSize

public void limitSize(int upperLimit,
                      int lowerLimit,
                      Comparator<DataPoint> dpComparator)

allows to limit this data map to a given number of keys. Only those remain that rank first on the given comparator. WARNING: if the limit is reached the purge operation may have a significant impact on performance depending on the comparator given. If you don't want such performance hit, then do not use a comparator.

Parameters:

upperLimit - is in effect if larger than 0

lowerLimit - must be between 0 and the upperLimit; if the upper limit is reached, data is purged to the lower limit

dpComparator - the comparator to be used

See Also:

limitSize(int), UniversalComparator.reverse(Comparator), DataPoint.COUNT_COMPARATOR, DataPoint.SUM_COMPARATOR

purge

public void purge(int limit,
                  Comparator<DataPoint> comparator)

checkSize

protected void checkSize()

getSnapshotModel

public DataMap.SnapshotModel getSnapshotModel()

getCategories

public Set<T> getCategories()

getValue

public DataPoint getValue(T category)

getValueForAll

public DataPoint getValueForAll()

getSortedKeys

public ArrayList<T> getSortedKeys()

uses the natural order or - if not applicable - a UniversalComparator

getSortedKeys

public ArrayList<T> getSortedKeys(Comparator<? super T> comp)

provides a sorted snapshot of the keys in this data map

Parameters:

comp - if null and T does not implement Comparable, a UniversalComparator is used

Returns:

a sorted snapshot of the keys currently present in a newly created, independent list

See Also:

UniversalComparator.getDefaultInstance()

containsKey

public boolean containsKey(T key)

getView

public Map<T,DataPoint> getView()

clear

public void clear()

size

public int size()

isEmpty

public boolean isEmpty()