A partial implementation of a dated map. This class is designed
to make it easier to implement the DatedMap interface. To create an unmodifiable
dated map, the client should subclass this class and implement entrySet.
The set returned by this method should be unmodifiable as well. To
create a modifiable dated map, the client should subclass this class,
implement the put method, and return an entry set that supports
clear and has an iterator that supports remove.

containsKeyThroughout

Returns true if this dated map contains the specified key
throughout the specified date range.
This implementation uses the date iterator to iterate through this map's
changed states, calling containsKey at each date range.

entrySet

Returns a modifiable view of the mappings of this dated map. The returned
dated set is backed by this dated map, so changes to the dated map
are reflected in the dated set and vice versa. The dated set
supports removal but not insertion.

equals

Indicates if this dated object at at is equal to
obj at objAt.
This implementation uses object identity to determine equality. In other
words, it returns true if

this == obj && date.equals( objDate )

Subclasses should override this method to impose a weaker equality condition.

Two maps are equivalent if they contain the same mappings.
This implementation returns true if this dated map and obj are the same
references and if date equals objDate. Then it returns false if
obj does not implement DatedMap. Finally, it returns true if this map's
entry set and obj's entry set are equivalent at these dates.

excludesKeyThroughout

Returns true if this dated map does not contain the specified key
at any date within the specified date range.
This implementation uses the date iterator to iterate through this map's
changed states, calling containsKey at each date range.

get

Returns the values associated with the specified key for all dates. The
returned dated value is backed by this dated map. Thus, changes to the
dated value are reflected in this dated map and vice versa. Setting a value
in the dated value is equivalent to invoking put on this map. Setting
a value to null is not equivalent to removing the key from
this map. A null value may mean either that the key is associated with
null or that the key is not present in this map. (This behavior
is consistent with the specification of get in java.util.Map).

If this map does not support put, then set of the
dated value will throw an UnsupportedOperationException.

Iteration through the dates of the dated value may result in a
ConcurrentModificationException if this map's dates are altered during
the iteration.

This implementation returns a freshly constructed DatedValue
that invokes AbstractDatedMap.this.get(K,D) in response
to get(D) and AbstractDatedMap.this.put(K,V,D,D)
in response to set(V,D,D). The date iterator that
it returns is this map's date iterator adapted to ignore dates
that do not reflect a change in the key's mapping.

hashCode

Returns a hash code value of this dated object at the specified date.
For two dated objects o1 and o2 and two dates
d1 and d2, if
o1.equals( d1, o2, d2 ) returns true,
then o1.hashCode( d1 )
must equal o2.hashCode( d2 ).
This implementation returns the identity hash code value of this dated
object.

The hash code of a DatedMap at a date is calculated the same way as in
hashCode of java.util.Map.
This implementation invokes hashCode(date) on the entry set.

hasSizeThroughout

Returns true if the size of this dated map is greater than or equal to
the specified size throughout the specified date range.
This implementation invokes hasSizeThroughout(size,from,to) on the entry set.

keySet

Returns a modifiable view of the keys of this dated map. The returned
dated set is backed by this dated map, so changes to the dated map
are reflected in the dated set and vice versa. The dated set
supports removal but not insertion.
This implementation returns a DatedSet that implements clear and has
an iterator that implements remove. All underlying actions operate on
this map's entry set.

putAll

Places all mappings in datedMap into this dated map (optional operation).
If this dated map and the map passed in are connected in a way that the map
changes during any additions, this method is undefined. This means that this
method cannot handle this as the parameter.
This implementation iterates through the dates of datedMap, invoking
put for each mapping and date range defined in datedMap.

remove

Removes any values associated with the specified key in the specified
date range (optional operation).
This implementation iterates through the entry set at each date between
from and to and invokes remove on the
iterator at the first occurrence of an entry with the key key.

values

Returns a view of the values mapped to keys in this dated map. The returned
dated collection is backed by this dated map, so changes to the dated map
are reflected in the dated collection and vice versa. The dated collection
supports removal but not insertion.
This implementation returns a dated collection that supports clear and
has an iterator that supports remove. All underlying actions operate on
this map's entry set.