org.rrd4j.core

## Interface Robin

- All Superinterfaces:
    RrdUpdater<Robin>
  All Known Implementing Classes:
    RobinArray, RobinMatrix

      public interface Robin
      extends RrdUpdater<Robin>

  Class to represent archive values for a single datasource. Robin class is the heart of the so-called "round robin database" concept. Basically, each Robin object is a fixed length array of double values. Each double value represents consolidated, archived value for the specific timestamp. When the underlying array of double values gets completely filled, new values will replace the oldest ones.

  Robin object does not hold values in memory - such object could be quite large. Instead of it, Robin reads them from the backend I/O only when necessary.

- - ### Method Summary

    All Methods Instance Methods Abstract Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `bulkStore(double newValue, int bulkCount)` bulkStore.
    `void` | `copyStateTo(Robin other)` copyStateTo.
    `String` | `dump()` dump.
    `void` | `filterValues(double minValue, double maxValue)` Filters values stored in this archive based on the given boundary.
    `Archive` | `getParent()` Returns the Archive object to which this Robin object belongs.
    `RrdAllocator` | `getRrdAllocator()` Required to implement RrdUpdater interface.
    `RrdBackend` | `getRrdBackend()` Returns the underlying storage (backend) object which actually performs all I/O operations.
    `int` | `getSize()` Returns the size of the underlying array of archived values.
    `double` | `getValue(int index)` Returns the i-th value from the Robin archive.
    `double[]` | `getValues()` Fetches all archived values.
    `double[]` | `getValues(int index, int count)` getValues.
    `void` | `setValue(int index, double value)` Sets the i-th value in the Robin archive.
    `void` | `setValues(double... newValues)` Updates archived values in bulk.
    `void` | `setValues(double newValue)` (Re)sets all values in this archive to the same value.
    `void` | `store(double newValue)` store.
    `void` | `update(double[] newValues)` update.

- - ### Method Detail

    - #### bulkStore

          void bulkStore(double newValue,
                         int bulkCount)
                  throws IOException

      bulkStore.
      Parameters:
        `newValue` - a double.
        `bulkCount` - a int.
      Throws:
        `IOException` - if any.

    - #### copyStateTo

          void copyStateTo(Robin other)
                    throws IOException

      copyStateTo.

      Copies object's internal state to another Robin object.

      Specified by:
        `copyStateTo` in interface `RrdUpdater<Robin>`
      Parameters:
        `other` - a `RrdUpdater` object.
      Throws:
        `IOException` - if any.

    - #### dump

          String dump()
               throws IOException

      dump.
      Returns:
        a `String` object.
      Throws:
        `IOException` - if any.

    - #### filterValues

          void filterValues(double minValue,
                            double maxValue)
                     throws IOException

      Filters values stored in this archive based on the given boundary. Archived values found to be outside of `[minValue, maxValue]` interval (inclusive) will be silently replaced with `NaN`.
      Parameters:
        `minValue` - lower boundary
        `maxValue` - upper boundary
      Throws:
        `IOException` - Thrown in case of I/O error

    - #### getParent

          Archive getParent()

      Returns the Archive object to which this Robin object belongs.
      Returns:
        Parent Archive object

    - #### getRrdAllocator

          RrdAllocator getRrdAllocator()

      Required to implement RrdUpdater interface. You should never call this method directly.
      Specified by:
        `getRrdAllocator` in interface `RrdUpdater<Robin>`
      Returns:
        Allocator object

    - #### getRrdBackend

          RrdBackend getRrdBackend()

      Returns the underlying storage (backend) object which actually performs all I/O operations.
      Specified by:
        `getRrdBackend` in interface `RrdUpdater<Robin>`
      Returns:
        I/O backend object

    - #### getSize

          int getSize()

      Returns the size of the underlying array of archived values.
      Returns:
        Number of stored values

    - #### getValue

          double getValue(int index)
                   throws IOException

      Returns the i-th value from the Robin archive.
      Parameters:
        `index` - Value index
      Returns:
        Value stored in the i-th position (the oldest value has zero index)
      Throws:
        `IOException` - Thrown in case of I/O specific error.

    - #### getValues

          double[] getValues()
                      throws IOException

      Fetches all archived values.
      Returns:
        Array of double archive values, starting from the oldest one.
      Throws:
        `IOException` - Thrown in case of I/O specific error.

    - #### getValues

          double[] getValues(int index,
                             int count)
                      throws IOException

      getValues.
      Parameters:
        `index` - a int.
        `count` - a int.
      Returns:
        an array of double.
      Throws:
        `IOException` - if any.

    - #### setValue

          void setValue(int index,
                        double value)
                 throws IOException

      Sets the i-th value in the Robin archive.
      Parameters:
        `index` - index in the archive (the oldest value has zero index)
        `value` - value to be stored
      Throws:
        `IOException` - Thrown in case of I/O specific error.

    - #### setValues

          void setValues(double... newValues)
                  throws IOException

      Updates archived values in bulk.
      Parameters:
        `newValues` - Array of double values to be stored in the archive
      Throws:
        `IOException` - Thrown in case of I/O error
        `IllegalArgumentException` - Thrown if the length of the input array is different from the length of this archive

    - #### setValues

          void setValues(double newValue)
                  throws IOException

      (Re)sets all values in this archive to the same value.
      Parameters:
        `newValue` - New value
      Throws:
        `IOException` - Thrown in case of I/O error

    - #### store

          void store(double newValue)
              throws IOException

      store.
      Parameters:
        `newValue` - a double.
      Throws:
        `IOException` - if any.

    - #### update

          void update(double[] newValues)
               throws IOException

      update.
      Parameters:
        `newValues` - an array of double.
      Throws:
        `IOException` - if any.