algolia / algoliasearch-client-java-2 / 956

79%

master: 77%

Pull #517

travis-ci

changed: Use getters/setters of base class Query for ConsequenceParams

The current `ConsequenceParams` class lets the user build instances
using a builder pattern. This way, a user can do:

```
ConsequenceParams params = new ConsequenceParams()
                                 .setFilters(...)
                                 .setAutomaticFacetFilters(...)
```

Because `ConsequenceParams` can accept all the possible parameters of a
`Query` object, it extends it. However, because the `ConsequenceParams`
is expected as a return type of each setter, we couldn't simply expect
to use the setters of the `ConsequenceParams` base class `Query`, even
though they are exactly the same.

This commit proposes to use a Java technique called self-referencing
generics to replace the concrete return type of the `Query` base class
setters with a self-referencing `T` generic type. Using this, all
setters can now be shared between the base class and the derived class,
with a the appropriate type signature, without having to override them
in the derived class.

To make it more clear, here is an minimal example of the code we had
before:

```
class A {
  protected int i;

  public A setI(int i) {
    this.i = i;
    return this;
  }
}

class B<T> extends A {
  private T something;

  public B setI(int i) {
    this.i = i;
    return this;
  }

  public B setSomething(T something) {
    this.something = something;
    return this;
  }
}
```

vs. the code we have now:

```
class A<T extends A<T>> {
  protected int i;

  public T setI(int i) {
    this.i = i;
    return (T) this;
  }
}

class B<T> extends A<B<T>> {
  private T something;

  public B setSomething(T something) {
    this.something = something;
    return this;
  }
}
```

where `A`/`B` respectively map to `Query`/`ConsequenceParams`. As shown,
all the setters are completely made unnecessary in the derived class.

69 of 69 new or added lines in 1 file covered. (100.0%)

2796 of 3549 relevant lines covered (78.78%)

0.79 hits per line