Package generic

# Class RangeMapSetter<E,D,R,V>

java.lang.Object
generic.RangeMapSetter<E,D,R,V>

Type Parameters:
  `E` - the type of entries
  `D` - the type of range bounds
  `R` - the type of ranges
  `V` - the type of values

Direct Known Subclasses:
  `DBTraceUtils.AddressRangeMapSetter`, `DBTraceUtils.LifespanMapSetter`, `Span.SpanMapSetter`

public abstract class RangeMapSetter<E,D,R,V> extends Object
A method outline for setting an entry in a range map where coalescing is desired

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `RangeMapSetter()`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `protected abstract int`
  `compare(D d1, D d2)`
  Compare two values as in `Comparator.compare(Object, Object)`
  `protected boolean`
  `connects(R r1, R r2)`
  Check if the two ranges are connected
  `protected abstract Iterable<E>`
  `getIntersecting(D lower, D upper)`
  Get all entries intersecting the closed range formed by the given bounds
  `protected abstract D`
  `getLower(R range)`
  Get the lower bound of the range
  `protected abstract D`
  `getNext(D d)`
  Get the number immediately following the given bound
  `protected D`
  `getNextOrSame(D d)`
  Get the next bound or this same bound, if the next doesn't exist
  `protected abstract D`
  `getPrevious(D d)`
  Get the number immediately preceding the given bound
  `protected D`
  `getPreviousOrSame(D d)`
  Get the previous bound or this same bound, if the previous doesn't exist
  `protected abstract R`
  `getRange(E entry)`
  Get the range of the given entry
  `protected abstract D`
  `getUpper(R range)`
  Get the upper bound of the range
  `protected abstract V`
  `getValue(E entry)`
  Get the value of the given entry
  `protected abstract E`
  `put(R range, V value)`
  Place an entry into the map
  `protected abstract void`
  `remove(E entry)`
  Remove an entry from the map
  `E`
  `set(D lower, D upper, V value)`
  Entry point: Set the given range to the given value, coalescing where possible
  `E`
  `set(R range, V value)`
  Entry point: Set the given range to the given value, coalescing where possible
  `protected abstract R`
  `toSpan(D lower, D upper)`
  Create a closed range with the given bounds
  `protected boolean`
  `valuesEqual(V v1, V v2)`
  Check if two values are equal

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

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

- ## Constructor Details

  - ### RangeMapSetter

    public RangeMapSetter()

- ## Method Details

  - ### compare

    protected abstract int compare(D d1, D d2)
    Compare two values as in `Comparator.compare(Object, Object)`
    Parameters:
      `d1` - the first value
      `d2` - the second value
    Returns:
      the result

  - ### getRange

    protected abstract R getRange(E entry)
    Get the range of the given entry
    Parameters:
      `entry` - the entry
    Returns:
      the range

  - ### getValue

    protected abstract V getValue(E entry)
    Get the value of the given entry
    Parameters:
      `entry` - the entry
    Returns:
      the value

  - ### valuesEqual

    protected boolean valuesEqual(V v1, V v2)
    Check if two values are equal
    Parameters:
      `v1` - the first value
      `v2` - the second value
    Returns:
      true if equal, false if not

  - ### remove

    protected abstract void remove(E entry)
    Remove an entry from the map
    Parameters:
      `entry` - the entry

  - ### getLower

    protected abstract D getLower(R range)
    Get the lower bound of the range
    Parameters:
      `range` - the range
    Returns:
      the lower bound

  - ### getUpper

    protected abstract D getUpper(R range)
    Get the upper bound of the range
    Parameters:
      `range` - the range
    Returns:
      the upper bound

  - ### toSpan

    protected abstract R toSpan(D lower, D upper)
    Create a closed range with the given bounds
    Parameters:
      `lower` - the lower bound
      `upper` - the upper bound
    Returns:
      the range

  - ### getPrevious

    protected abstract D getPrevious(D d)
    Get the number immediately preceding the given bound
    Parameters:
      `d` - the bound
    Returns:
      the previous bound, or null if it doesn't exist

  - ### getNext

    protected abstract D getNext(D d)
    Get the number immediately following the given bound
    Parameters:
      `d` - the bound
    Returns:
      the next bound, or null if it doesn't exist

  - ### getIntersecting

    protected abstract Iterable<E> getIntersecting(D lower, D upper)
    Get all entries intersecting the closed range formed by the given bounds
    Parameters:
      `lower` - the lower bound
      `upper` - the upper bound
    Returns:
      the intersecting entries

  - ### put

    protected abstract E put(R range, V value)
    Place an entry into the map
    Parameters:
      `range` - the range of the entry
      `value` - the value of the entry
    Returns:
      the new entry (or an existing entry)

  - ### getPreviousOrSame

    protected D getPreviousOrSame(D d)
    Get the previous bound or this same bound, if the previous doesn't exist
    Parameters:
      `d` - the bound
    Returns:
      the previous or same bound

  - ### getNextOrSame

    protected D getNextOrSame(D d)
    Get the next bound or this same bound, if the next doesn't exist
    Parameters:
      `d` - the bound
    Returns:
      the next or same bound

  - ### connects

    protected boolean connects(R r1, R r2)
    Check if the two ranges are connected

    The ranges are connected if they intersect, or if their bounds abut.

    Parameters:
      `r1` - the first range
      `r2` - the second range
    Returns:
      true if connected

  - ### set

    public E set(R range, V value)
    Entry point: Set the given range to the given value, coalescing where possible
    Parameters:
      `range` - the range
      `value` - the value
    Returns:
      the entry containing the value

  - ### set

    public E set(D lower, D upper, V value)
    Entry point: Set the given range to the given value, coalescing where possible
    Parameters:
      `lower` - the lower bound
      `upper` - the upper bound
      `value` - the value
    Returns:
      the entry containing the value