// now synchronized

persistable sclass MultiBest<A> {

  Cl<A> best = new L;

  double score = negativeInfinity();

  bool verboseNewBest;

  synchronized double bestScore aka score aka getScore() {

    ret best == null ? minusInfinity() : score;

  }

  bool isEmpty() { ret best.isEmpty(); }

  synchronized float floatScoreOr(float defaultValue) {

    ret best == null ? defaultValue : (float) score;

  }

  void put(Pair<? extends A, Double> p) {

    if (p != null) put(p.a, p.b);

  }

  void put(A a, double score) {

    ping();

    bool newBest;

    if (a != null) synchronized(this) {

      if (score > this.score) {

        best.clear();

        this.score = score;

        set newBest;

      }

      if (score >= this.score) {

        best.add(a);

      }

    }

    if (newBest && verboseNewBest) print("New best! " + this);

  }

  synchronized Cl<A> get() { ret best; }

  synchronized bool has() { ret !isEmpty(); }

  toString {

    ret isEmpty() ? "-"

      : "Score " + formatDouble_significant2(score, 4)

        + (tied() ? ", " + nWinners(duplicity()) : "")

        + ": " + joinWithComma(map stringify(best));

  }

  S stringify(A a) { ret str(a); }

  bool tied() { ret duplicity() > 1; }

  int duplicity() { ret best.size(); }

  synchronized void clear() { best.clear(); score = 0; }

}