Class AggregationIterator

src/core/AggregationIterator.java:120–846

Iterator that aggregates multiple spans or time series data and does linear interpolation (lerp) for missing data points. This where the real business of SpanGroup is. This iterator provides a merged, aggregated view of multiple Spans. The data points in all the Spans are retur

 * <p>
 */
public class AggregationIterator implements SeekableView, DataPoint,
                                           Aggregator.Longs, Aggregator.Doubles {

  private static final Logger LOG =
      LoggerFactory.getLogger(AggregationIterator.class);

  /** Extra bit we set on the timestamp of floating point values. */
  private static final long FLAG_FLOAT = 0x8000000000000000L;

  /** Mask to use in order to get rid of the flag above.
   * This value also conveniently represents the largest timestamp we can
   * possibly store, provided that the most significant bit is reserved by
   * FLAG_FLOAT.
   */
  protected static final long TIME_MASK  = 0x7FFFFFFFFFFFFFFFL;

  /** Aggregator to use to aggregate data points from different Spans. */
  private final Aggregator aggregator;

  /** Interpolation method to use when aggregating time series */
  private final Interpolation method;

  /** If true, use rate of change instead of actual values. */
  private final boolean rate;

  /**
   * Where we are in each {@link Span} in the group.
   * The iterators in this array always points to 2 values ahead of the
   * current value, as we pre-load the current and the next values into the
   * {@link #timestamps} and {@link #values} member.
   * Once we reach the end of a Span, we'll null out its iterator from this
   * array.
   */
  protected final SeekableView[] iterators;

  /** Start time (UNIX timestamp in seconds or ms) on 32 bits ("unsigned" int). */
  protected final long start_time;

  /** End time (UNIX timestamp in seconds or ms) on 32 bits ("unsigned" int). */
  protected final long end_time;

  /**
   * The current and previous timestamps for the data points being used.
   * <p>
   * Are we computing a rate?
   * <ul>
   * <li>No: for {@code iterators[i]} the timestamp of the current data
   *     point is {@code timestamps[i]} and the timestamp of the next data
   *     point is {@code timestamps[iterators.length + i]}.</li>
   * </ul>
   * <p>
   * Each timestamp can have the {@code FLAG_FLOAT} applied so it's important
   * to use the {@code TIME_MASK} when getting the actual timestamp value
   * out of it.
   * There are two special values for timestamps:
   * <ul>
   * <li>{@code 0} when in the first half of the array: this iterator has
   * run out of data points and must not be used anymore.</li>