Overview | Package | Class | Tree | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## de.grogra.xl.util
Class Operators

    java.lang.Object
      de.grogra.xl.util.Operators

    public final class Operators

extends java.lang.Object

Method Summary
`static java.lang.reflect.Array` | `array(Aggregate a, boolean value)`
`static java.lang.reflect.Array` | `array(Aggregate a, byte value)`
`static java.lang.reflect.Array` | `array(Aggregate a, char value)`
`static java.lang.reflect.Array` | `array(Aggregate a, double value)`
`static java.lang.reflect.Array` | `array(Aggregate a, float value)`
`static java.lang.reflect.Array` | `array(Aggregate a, int value)`
`static java.lang.reflect.Array` | `array(Aggregate a, long value)`
`static java.lang.reflect.Array` | `array(Aggregate a, java.lang.Object value)`
`static java.lang.reflect.Array` | `array(Aggregate a, short value)`
`static long` | `count(Aggregate a, boolean value)`
`static long` | `count(Aggregate a, double value)`
`static long` | `count(Aggregate a, float value)`
`static long` | `count(Aggregate a, int value)`
`static long` | `count(Aggregate a, long value)`
`static long` | `count(Aggregate a, java.lang.Object value)`
`static boolean` | `empty(Aggregate a, boolean value)`
`static boolean` | `empty(Aggregate a, double value)`
`static boolean` | `empty(Aggregate a, float value)`
`static boolean` | `empty(Aggregate a, int value)`
`static boolean` | `empty(Aggregate a, long value)`
`static boolean` | `empty(Aggregate a, java.lang.Object value)`
`static void` | `exist(Aggregate a, boolean value)`
`static void` | `first(Aggregate a, boolean value)`
`static void` | `first(Aggregate a, byte value)`
`static void` | `first(Aggregate a, char value)`
`static void` | `first(Aggregate a, double value)`
`static void` | `first(Aggregate a, float value)`
`static void` | `first(Aggregate a, int value)`
`static void` | `first(Aggregate a, long value)`
`static void` | `first(Aggregate a, java.lang.Object value)`
`static void` | `first(Aggregate a, short value)`
`static void` | `first(Filter f, boolean value, long count)`
`static void` | `first(Filter f, byte value, long count)`
`static void` | `first(Filter f, char value, long count)`
`static void` | `first(Filter f, double value, long count)`
`static void` | `first(Filter f, float value, long count)`
`static void` | `first(Filter f, int value, long count)`
`static void` | `first(Filter f, long value, long count)`
`static void` | `first(Filter f, java.lang.Object value, long count)`
`static void` | `first(Filter f, short value, long count)`
`static void` | `forall(Aggregate a, boolean value)`
`static java.util.Random` | `getRandomGenerator()`
`static void` | `last(Aggregate a, boolean value)`
`static void` | `last(Aggregate a, byte value)`
`static void` | `last(Aggregate a, char value)`
`static void` | `last(Aggregate a, double value)`
`static void` | `last(Aggregate a, float value)`
`static void` | `last(Aggregate a, int value)`
`static void` | `last(Aggregate a, long value)`
`static void` | `last(Aggregate a, java.lang.Object value)`
`static void` | `last(Aggregate a, short value)`
`static void` | `max(Aggregate a, byte value)`
`static void` | `max(Aggregate a, double value)`
`static void` | `max(Aggregate a, float value)`
`static void` | `max(Aggregate a, int value)`
`static void` | `max(Aggregate a, long value)`
`static void` | `max(Aggregate a, short value)`
`static void` | `mean(Aggregate a, double value)`
`static void` | `mean(Aggregate a, float value)`
`static void` | `mean(Aggregate a, int value)`
`static void` | `mean(Aggregate a, long value)`
`static void` | `min(Aggregate a, byte value)`
`static void` | `min(Aggregate a, double value)`
`static void` | `min(Aggregate a, float value)`
`static void` | `min(Aggregate a, int value)`
`static void` | `min(Aggregate a, long value)`
`static void` | `min(Aggregate a, short value)`
`static void` | `prod(Aggregate a, double value)`
`static void` | `prod(Aggregate a, float value)`
`static void` | `prod(Aggregate a, int value)`
`static void` | `prod(Aggregate a, long value)`
`static void` | `selectRandomly(Aggregate a, boolean value)`
`static void` | `selectRandomly(Aggregate a, boolean value, double prob)` This aggregate method selects one of the provided `value`s, where each `value` has a relative probability `prob` of being chosen.
`static void` | `selectRandomly(Aggregate a, byte value)`
`static void` | `selectRandomly(Aggregate a, byte value, double prob)` This aggregate method selects one of the provided `value`s, where each `value` has a relative probability `prob` of being chosen.
`static void` | `selectRandomly(Aggregate a, char value)`
`static void` | `selectRandomly(Aggregate a, char value, double prob)` This aggregate method selects one of the provided `value`s, where each `value` has a relative probability `prob` of being chosen.
`static void` | `selectRandomly(Aggregate a, double value)`
`static void` | `selectRandomly(Aggregate a, double value, double prob)` This aggregate method selects one of the provided `value`s, where each `value` has a relative probability `prob` of being chosen.
`static void` | `selectRandomly(Aggregate a, float value)`
`static void` | `selectRandomly(Aggregate a, float value, double prob)` This aggregate method selects one of the provided `value`s, where each `value` has a relative probability `prob` of being chosen.
`static void` | `selectRandomly(Aggregate a, int value)`
`static void` | `selectRandomly(Aggregate a, int value, double prob)` This aggregate method selects one of the provided `value`s, where each `value` has a relative probability `prob` of being chosen.
`static void` | `selectRandomly(Aggregate a, long value)`
`static void` | `selectRandomly(Aggregate a, long value, double prob)` This aggregate method selects one of the provided `value`s, where each `value` has a relative probability `prob` of being chosen.
`static void` | `selectRandomly(Aggregate a, java.lang.Object value)`
`static void` | `selectRandomly(Aggregate a, java.lang.Object value, double prob)` This aggregate method selects one of the provided `value`s, where each `value` has a relative probability `prob` of being chosen.
`static void` | `selectRandomly(Aggregate a, short value)`
`static void` | `selectRandomly(Aggregate a, short value, double prob)` This aggregate method selects one of the provided `value`s, where each `value` has a relative probability `prob` of being chosen.
`static void` | `selectWhere(Aggregate a, boolean value, boolean sel)`
`static void` | `selectWhere(Aggregate a, byte value, boolean sel)`
`static void` | `selectWhere(Aggregate a, char value, boolean sel)`
`static void` | `selectWhere(Aggregate a, double value, boolean sel)`
`static void` | `selectWhere(Aggregate a, float value, boolean sel)`
`static void` | `selectWhere(Aggregate a, int value, boolean sel)`
`static void` | `selectWhere(Aggregate a, long value, boolean sel)`
`static void` | `selectWhere(Aggregate a, java.lang.Object value, boolean sel)`
`static void` | `selectWhere(Aggregate a, short value, boolean sel)`
`static void` | `selectWhereMax(Aggregate a, boolean value, double n)`
`static void` | `selectWhereMax(Aggregate a, boolean value, long n)`
`static void` | `selectWhereMax(Aggregate a, byte value, double n)`
`static void` | `selectWhereMax(Aggregate a, byte value, long n)`
`static void` | `selectWhereMax(Aggregate a, char value, double n)`
`static void` | `selectWhereMax(Aggregate a, char value, long n)`
`static void` | `selectWhereMax(Aggregate a, double value, double n)`
`static void` | `selectWhereMax(Aggregate a, double value, long n)`
`static void` | `selectWhereMax(Aggregate a, float value, double n)`
`static void` | `selectWhereMax(Aggregate a, float value, long n)`
`static void` | `selectWhereMax(Aggregate a, int value, double n)`
`static void` | `selectWhereMax(Aggregate a, int value, long n)`
`static void` | `selectWhereMax(Aggregate a, long value, double n)`
`static void` | `selectWhereMax(Aggregate a, long value, long n)`
`static void` | `selectWhereMax(Aggregate a, java.lang.Object value, double n)`
`static void` | `selectWhereMax(Aggregate a, java.lang.Object value, long n)`
`static void` | `selectWhereMax(Aggregate a, short value, double n)`
`static void` | `selectWhereMax(Aggregate a, short value, long n)`
`static void` | `selectWhereMin(Aggregate a, boolean value, double n)`
`static void` | `selectWhereMin(Aggregate a, boolean value, long n)`
`static void` | `selectWhereMin(Aggregate a, byte value, double n)`
`static void` | `selectWhereMin(Aggregate a, byte value, long n)`
`static void` | `selectWhereMin(Aggregate a, char value, double n)`
`static void` | `selectWhereMin(Aggregate a, char value, long n)`
`static void` | `selectWhereMin(Aggregate a, double value, double n)`
`static void` | `selectWhereMin(Aggregate a, double value, long n)`
`static void` | `selectWhereMin(Aggregate a, float value, double n)`
`static void` | `selectWhereMin(Aggregate a, float value, long n)`
`static void` | `selectWhereMin(Aggregate a, int value, double n)`
`static void` | `selectWhereMin(Aggregate a, int value, long n)`
`static void` | `selectWhereMin(Aggregate a, long value, double n)`
`static void` | `selectWhereMin(Aggregate a, long value, long n)`
`static void` | `selectWhereMin(Aggregate a, java.lang.Object value, double n)`
`static void` | `selectWhereMin(Aggregate a, java.lang.Object value, long n)`
`static void` | `selectWhereMin(Aggregate a, short value, double n)`
`static void` | `selectWhereMin(Aggregate a, short value, long n)`
`static void` | `slice(Filter f, boolean value, long start, long end)`
`static void` | `slice(Filter f, byte value, long start, long end)`
`static void` | `slice(Filter f, char value, long start, long end)`
`static void` | `slice(Filter f, double value, long start, long end)`
`static void` | `slice(Filter f, float value, long start, long end)`
`static void` | `slice(Filter f, int value, long start, long end)`
`static void` | `slice(Filter f, long value, long start, long end)`
`static void` | `slice(Filter f, java.lang.Object value, long start, long end)`
`static void` | `slice(Filter f, short value, long start, long end)`
`static java.lang.String` | `string(Aggregate a, boolean value)`
`static java.lang.String` | `string(Aggregate a, double value)`
`static java.lang.String` | `string(Aggregate a, float value)`
`static java.lang.String` | `string(Aggregate a, int value)`
`static java.lang.String` | `string(Aggregate a, long value)`
`static java.lang.String` | `string(Aggregate a, java.lang.Object value)`
`static void` | `sum(Aggregate a, double value)`
`static void` | `sum(Aggregate a, float value)`
`static void` | `sum(Aggregate a, int value)`
`static void` | `sum(Aggregate a, long value)`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Method Detail

### array

    public static java.lang.reflect.Array array(Aggregate a,
                                                boolean value)

### array

    public static java.lang.reflect.Array array(Aggregate a,
                                                byte value)

### array

    public static java.lang.reflect.Array array(Aggregate a,
                                                char value)

### array

    public static java.lang.reflect.Array array(Aggregate a,
                                                double value)

### array

    public static java.lang.reflect.Array array(Aggregate a,
                                                float value)

### array

    public static java.lang.reflect.Array array(Aggregate a,
                                                int value)

### array

    public static java.lang.reflect.Array array(Aggregate a,
                                                long value)

### array

    public static java.lang.reflect.Array array(Aggregate a,
                                                java.lang.Object value)

### array

    public static java.lang.reflect.Array array(Aggregate a,
                                                short value)

### count

    public static long count(Aggregate a,
                             boolean value)

### count

    public static long count(Aggregate a,
                             double value)

### count

    public static long count(Aggregate a,
                             float value)

### count

    public static long count(Aggregate a,
                             int value)

### count

    public static long count(Aggregate a,
                             long value)

### count

    public static long count(Aggregate a,
                             java.lang.Object value)

### empty

    public static boolean empty(Aggregate a,
                                boolean value)

### empty

    public static boolean empty(Aggregate a,
                                double value)

### empty

    public static boolean empty(Aggregate a,
                                float value)

### empty

    public static boolean empty(Aggregate a,
                                int value)

### empty

    public static boolean empty(Aggregate a,
                                long value)

### empty

    public static boolean empty(Aggregate a,
                                java.lang.Object value)

### exist

    public static void exist(Aggregate a,
                             boolean value)

### first

    public static void first(Aggregate a,
                             boolean value)

### first

    public static void first(Aggregate a,
                             byte value)

### first

    public static void first(Aggregate a,
                             char value)

### first

    public static void first(Aggregate a,
                             double value)

### first

    public static void first(Aggregate a,
                             float value)

### first

    public static void first(Aggregate a,
                             int value)

### first

    public static void first(Aggregate a,
                             long value)

### first

    public static void first(Aggregate a,
                             java.lang.Object value)

### first

    public static void first(Aggregate a,
                             short value)

### first

    public static void first(Filter f,
                             boolean value,
                             long count)

### first

    public static void first(Filter f,
                             byte value,
                             long count)

### first

    public static void first(Filter f,
                             char value,
                             long count)

### first

    public static void first(Filter f,
                             double value,
                             long count)

### first

    public static void first(Filter f,
                             float value,
                             long count)

### first

    public static void first(Filter f,
                             int value,
                             long count)

### first

    public static void first(Filter f,
                             long value,
                             long count)

### first

    public static void first(Filter f,
                             java.lang.Object value,
                             long count)

### first

    public static void first(Filter f,
                             short value,
                             long count)

### forall

    public static void forall(Aggregate a,
                              boolean value)

### getRandomGenerator

    public static java.util.Random getRandomGenerator()

### last

    public static void last(Aggregate a,
                            boolean value)

### last

    public static void last(Aggregate a,
                            byte value)

### last

    public static void last(Aggregate a,
                            char value)

### last

    public static void last(Aggregate a,
                            double value)

### last

    public static void last(Aggregate a,
                            float value)

### last

    public static void last(Aggregate a,
                            int value)

### last

    public static void last(Aggregate a,
                            long value)

### last

    public static void last(Aggregate a,
                            java.lang.Object value)

### last

    public static void last(Aggregate a,
                            short value)

### max

    public static void max(Aggregate a,
                           byte value)

### max

    public static void max(Aggregate a,
                           double value)

### max

    public static void max(Aggregate a,
                           float value)

### max

    public static void max(Aggregate a,
                           int value)

### max

    public static void max(Aggregate a,
                           long value)

### max

    public static void max(Aggregate a,
                           short value)

### mean

    public static void mean(Aggregate a,
                            double value)

### mean

    public static void mean(Aggregate a,
                            float value)

### mean

    public static void mean(Aggregate a,
                            int value)

### mean

    public static void mean(Aggregate a,
                            long value)

### min

    public static void min(Aggregate a,
                           byte value)

### min

    public static void min(Aggregate a,
                           double value)

### min

    public static void min(Aggregate a,
                           float value)

### min

    public static void min(Aggregate a,
                           int value)

### min

    public static void min(Aggregate a,
                           long value)

### min

    public static void min(Aggregate a,
                           short value)

### prod

    public static void prod(Aggregate a,
                            double value)

### prod

    public static void prod(Aggregate a,
                            float value)

### prod

    public static void prod(Aggregate a,
                            int value)

### prod

    public static void prod(Aggregate a,
                            long value)

### selectRandomly

    public static void selectRandomly(Aggregate a,
                                      boolean value)

### selectRandomly

    public static void selectRandomly(Aggregate a,
                                      boolean value,
                                      double prob)

  This aggregate method selects one of the provided `value`s, where each `value` has a relative probability `prob` of being chosen. Relative probability means that the `prob` values do not have to be normalized so that their sum is 1.

  Parameters:
    `a` - aggregate instance (provided by the XL compiler)
    `value` - a value of the sequence of values
    `prob` - relative probability of `value`

### selectRandomly

    public static void selectRandomly(Aggregate a,
                                      byte value)

### selectRandomly

    public static void selectRandomly(Aggregate a,
                                      byte value,
                                      double prob)

  This aggregate method selects one of the provided `value`s, where each `value` has a relative probability `prob` of being chosen. Relative probability means that the `prob` values do not have to be normalized so that their sum is 1.

  Parameters:
    `a` - aggregate instance (provided by the XL compiler)
    `value` - a value of the sequence of values
    `prob` - relative probability of `value`

### selectRandomly

    public static void selectRandomly(Aggregate a,
                                      char value)

### selectRandomly

    public static void selectRandomly(Aggregate a,
                                      char value,
                                      double prob)

  This aggregate method selects one of the provided `value`s, where each `value` has a relative probability `prob` of being chosen. Relative probability means that the `prob` values do not have to be normalized so that their sum is 1.

  Parameters:
    `a` - aggregate instance (provided by the XL compiler)
    `value` - a value of the sequence of values
    `prob` - relative probability of `value`

### selectRandomly

    public static void selectRandomly(Aggregate a,
                                      double value)

### selectRandomly

    public static void selectRandomly(Aggregate a,
                                      double value,
                                      double prob)

  This aggregate method selects one of the provided `value`s, where each `value` has a relative probability `prob` of being chosen. Relative probability means that the `prob` values do not have to be normalized so that their sum is 1.

  Parameters:
    `a` - aggregate instance (provided by the XL compiler)
    `value` - a value of the sequence of values
    `prob` - relative probability of `value`

### selectRandomly

    public static void selectRandomly(Aggregate a,
                                      float value)

### selectRandomly

    public static void selectRandomly(Aggregate a,
                                      float value,
                                      double prob)

  This aggregate method selects one of the provided `value`s, where each `value` has a relative probability `prob` of being chosen. Relative probability means that the `prob` values do not have to be normalized so that their sum is 1.

  Parameters:
    `a` - aggregate instance (provided by the XL compiler)
    `value` - a value of the sequence of values
    `prob` - relative probability of `value`

### selectRandomly

    public static void selectRandomly(Aggregate a,
                                      int value)

### selectRandomly

    public static void selectRandomly(Aggregate a,
                                      int value,
                                      double prob)

  This aggregate method selects one of the provided `value`s, where each `value` has a relative probability `prob` of being chosen. Relative probability means that the `prob` values do not have to be normalized so that their sum is 1.

  Parameters:
    `a` - aggregate instance (provided by the XL compiler)
    `value` - a value of the sequence of values
    `prob` - relative probability of `value`

### selectRandomly

    public static void selectRandomly(Aggregate a,
                                      long value)

### selectRandomly

    public static void selectRandomly(Aggregate a,
                                      long value,
                                      double prob)

  This aggregate method selects one of the provided `value`s, where each `value` has a relative probability `prob` of being chosen. Relative probability means that the `prob` values do not have to be normalized so that their sum is 1.

  Parameters:
    `a` - aggregate instance (provided by the XL compiler)
    `value` - a value of the sequence of values
    `prob` - relative probability of `value`

### selectRandomly

    public static void selectRandomly(Aggregate a,
                                      java.lang.Object value)

### selectRandomly

    public static void selectRandomly(Aggregate a,
                                      java.lang.Object value,
                                      double prob)

  This aggregate method selects one of the provided `value`s, where each `value` has a relative probability `prob` of being chosen. Relative probability means that the `prob` values do not have to be normalized so that their sum is 1.

  Parameters:
    `a` - aggregate instance (provided by the XL compiler)
    `value` - a value of the sequence of values
    `prob` - relative probability of `value`

### selectRandomly

    public static void selectRandomly(Aggregate a,
                                      short value)

### selectRandomly

    public static void selectRandomly(Aggregate a,
                                      short value,
                                      double prob)

  This aggregate method selects one of the provided `value`s, where each `value` has a relative probability `prob` of being chosen. Relative probability means that the `prob` values do not have to be normalized so that their sum is 1.

  Parameters:
    `a` - aggregate instance (provided by the XL compiler)
    `value` - a value of the sequence of values
    `prob` - relative probability of `value`

### selectWhere

    public static void selectWhere(Aggregate a,
                                   boolean value,
                                   boolean sel)

### selectWhere

    public static void selectWhere(Aggregate a,
                                   byte value,
                                   boolean sel)

### selectWhere

    public static void selectWhere(Aggregate a,
                                   char value,
                                   boolean sel)

### selectWhere

    public static void selectWhere(Aggregate a,
                                   double value,
                                   boolean sel)

### selectWhere

    public static void selectWhere(Aggregate a,
                                   float value,
                                   boolean sel)

### selectWhere

    public static void selectWhere(Aggregate a,
                                   int value,
                                   boolean sel)

### selectWhere

    public static void selectWhere(Aggregate a,
                                   long value,
                                   boolean sel)

### selectWhere

    public static void selectWhere(Aggregate a,
                                   java.lang.Object value,
                                   boolean sel)

### selectWhere

    public static void selectWhere(Aggregate a,
                                   short value,
                                   boolean sel)

### selectWhereMax

    public static void selectWhereMax(Aggregate a,
                                      boolean value,
                                      double n)

### selectWhereMax

    public static void selectWhereMax(Aggregate a,
                                      boolean value,
                                      long n)

### selectWhereMax

    public static void selectWhereMax(Aggregate a,
                                      byte value,
                                      double n)

### selectWhereMax

    public static void selectWhereMax(Aggregate a,
                                      byte value,
                                      long n)

### selectWhereMax

    public static void selectWhereMax(Aggregate a,
                                      char value,
                                      double n)

### selectWhereMax

    public static void selectWhereMax(Aggregate a,
                                      char value,
                                      long n)

### selectWhereMax

    public static void selectWhereMax(Aggregate a,
                                      double value,
                                      double n)

### selectWhereMax

    public static void selectWhereMax(Aggregate a,
                                      double value,
                                      long n)

### selectWhereMax

    public static void selectWhereMax(Aggregate a,
                                      float value,
                                      double n)

### selectWhereMax

    public static void selectWhereMax(Aggregate a,
                                      float value,
                                      long n)

### selectWhereMax

    public static void selectWhereMax(Aggregate a,
                                      int value,
                                      double n)

### selectWhereMax

    public static void selectWhereMax(Aggregate a,
                                      int value,
                                      long n)

### selectWhereMax

    public static void selectWhereMax(Aggregate a,
                                      long value,
                                      double n)

### selectWhereMax

    public static void selectWhereMax(Aggregate a,
                                      long value,
                                      long n)

### selectWhereMax

    public static void selectWhereMax(Aggregate a,
                                      java.lang.Object value,
                                      double n)

### selectWhereMax

    public static void selectWhereMax(Aggregate a,
                                      java.lang.Object value,
                                      long n)

### selectWhereMax

    public static void selectWhereMax(Aggregate a,
                                      short value,
                                      double n)

### selectWhereMax

    public static void selectWhereMax(Aggregate a,
                                      short value,
                                      long n)

### selectWhereMin

    public static void selectWhereMin(Aggregate a,
                                      boolean value,
                                      double n)

### selectWhereMin

    public static void selectWhereMin(Aggregate a,
                                      boolean value,
                                      long n)

### selectWhereMin

    public static void selectWhereMin(Aggregate a,
                                      byte value,
                                      double n)

### selectWhereMin

    public static void selectWhereMin(Aggregate a,
                                      byte value,
                                      long n)

### selectWhereMin

    public static void selectWhereMin(Aggregate a,
                                      char value,
                                      double n)

### selectWhereMin

    public static void selectWhereMin(Aggregate a,
                                      char value,
                                      long n)

### selectWhereMin

    public static void selectWhereMin(Aggregate a,
                                      double value,
                                      double n)

### selectWhereMin

    public static void selectWhereMin(Aggregate a,
                                      double value,
                                      long n)

### selectWhereMin

    public static void selectWhereMin(Aggregate a,
                                      float value,
                                      double n)

### selectWhereMin

    public static void selectWhereMin(Aggregate a,
                                      float value,
                                      long n)

### selectWhereMin

    public static void selectWhereMin(Aggregate a,
                                      int value,
                                      double n)

### selectWhereMin

    public static void selectWhereMin(Aggregate a,
                                      int value,
                                      long n)

### selectWhereMin

    public static void selectWhereMin(Aggregate a,
                                      long value,
                                      double n)

### selectWhereMin

    public static void selectWhereMin(Aggregate a,
                                      long value,
                                      long n)

### selectWhereMin

    public static void selectWhereMin(Aggregate a,
                                      java.lang.Object value,
                                      double n)

### selectWhereMin

    public static void selectWhereMin(Aggregate a,
                                      java.lang.Object value,
                                      long n)

### selectWhereMin

    public static void selectWhereMin(Aggregate a,
                                      short value,
                                      double n)

### selectWhereMin

    public static void selectWhereMin(Aggregate a,
                                      short value,
                                      long n)

### slice

    public static void slice(Filter f,
                             boolean value,
                             long start,
                             long end)

### slice

    public static void slice(Filter f,
                             byte value,
                             long start,
                             long end)

### slice

    public static void slice(Filter f,
                             char value,
                             long start,
                             long end)

### slice

    public static void slice(Filter f,
                             double value,
                             long start,
                             long end)

### slice

    public static void slice(Filter f,
                             float value,
                             long start,
                             long end)

### slice

    public static void slice(Filter f,
                             int value,
                             long start,
                             long end)

### slice

    public static void slice(Filter f,
                             long value,
                             long start,
                             long end)

### slice

    public static void slice(Filter f,
                             java.lang.Object value,
                             long start,
                             long end)

### slice

    public static void slice(Filter f,
                             short value,
                             long start,
                             long end)

### string

    public static java.lang.String string(Aggregate a,
                                          boolean value)

### string

    public static java.lang.String string(Aggregate a,
                                          double value)

### string

    public static java.lang.String string(Aggregate a,
                                          float value)

### string

    public static java.lang.String string(Aggregate a,
                                          int value)

### string

    public static java.lang.String string(Aggregate a,
                                          long value)

### string

    public static java.lang.String string(Aggregate a,
                                          java.lang.Object value)

### sum

    public static void sum(Aggregate a,
                           double value)

### sum

    public static void sum(Aggregate a,
                           float value)

### sum

    public static void sum(Aggregate a,
                           int value)

### sum

    public static void sum(Aggregate a,
                           long value)

Overview | Package | Class | Tree | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD