sclass JE_CompressEachElementIndividually<El> extends AbstractCompressor_AnyType<IJavaExpr, L<El>> {
  settable IF0<AbstractCompressor_AnyType<IJavaExpr, El>> elementCompressionStrategy;
  new L<CompressionSearch_AnyType<IJavaExpr, El>> searches;
  settable IF1<El, IJavaExpr> makeLiteral; // required
  settable bool debug;

  // internal
  
  new L<IJavaExpr> renderedElements;
  IJavaExpr renderedCode;
  new BitSet dirtyElements;
  
  int size() { ret l(inputData()); }
  int nNotLiteral() { ret countPred(searches, search -> search.has()); }
  
  scaffolded IJavaExpr getRenderedElement(int i) {
    if (contains(dirtyElements, i) || empty(_get(renderedElements, i))) {
      remove(dirtyElements, i);
      //print("Rendering element " + (i+1) + "/" + size());
      var e = renderElement(i);
      listSet(renderedElements, i, e);
      //print("  => " + e);
    }
    ret renderedElements.get(i);
  }
    
  IJavaExpr renderElement(int i) {
    var search = _get(searches, i);
    IJavaExpr comp = search?!;
    ret comp != null ? comp : makeLiteral.get(_get(inputData(), i));
  }
  
  bool dirty() { ret nempty(dirtyElements) || l(renderedElements) < size(); }
  
  public void flush {
    if (!dirty()) ret;
    submit(code());
  }
  
  // get current best compressed representation
  IJavaExpr code() {
    if (dirty() || renderedCode == null) {
      L<IJavaExpr> els = countIteratorToList getRenderedElement(size());
      renderedCode = javaExpr(
           functionCall_list ll(els),
        -> mapQuickEval_javaExpr(els));
    }
    ret renderedCode;
  }

  // start compressors  
  run {
    if (elementCompressionStrategy == null) ret;
    
    probabilisticForEach(scheduler(), 1.0, 0.5, indexAsSideValue(inputData()), new IF1<El, Runnable>() {
      public Runnable get(WithSideValue<Int, El> data) {
        int i = data.sideValue();
        var subSearch = new CompressionSearch_AnyType<IJavaExpr, El>(assertNotNull(+regime()), data!);
        subSearch.onNewBest(-> set(dirtyElements, i));
        listSet(searches, i, subSearch);
        subSearch.addStrategy(elementCompressionStrategy!);
        ret subSearch;
      }
      
      toString { ret "Compress " + data; }
    });
  }
  
  S stats() {
    ret renderVars(+nNotLiteral());
  }
}