<br />
<b>Warning</b>:  session_start(): open(/var/lib/php/sessions/sess_rg03mmf7a6ejnfr22slkl3lrl8, O_RDWR) failed: No space left on device (28) in <b>/var/www/tb-usercake/models/config.php</b> on line <b>51</b><br />
<br />
<b>Warning</b>:  session_start(): Failed to read session data: files (path: /var/lib/php/sessions) in <b>/var/www/tb-usercake/models/config.php</b> on line <b>51</b><br />
sclass LineCompCompressor {
  replace Encodings with Map<S, L<Int>>.
  
  bool verbose = false;
  bool sortLines = true;
  bool verify = true;
  
  Map<S, LS> textIDToLines = mapValuesToLinkedHashMap lines(versions);
  LS allUniqueLines;
  new L<Chunk> chunks;
  int primChunks;
  Map<S, Int> lineIndex;
  new Map<PairS, Int> linePairIndex;
  Encodings finalEncodings;
  
  // key = version ID, values = text
  *(SS texts) {
    textIDToLines = mapValuesToLinkedHashMap lines(texts);
  }
  
  run {
    allUniqueLines = uniquify(concatLists(values(textIDToLines)));
    if (sortLines) sortInPlace(allUniqueLines);
    for (S line : allUniqueLines)
      chunks.add(new CPrim(line));
    primChunks = l(chunks);
    lineIndex = listIndex(collect s(chunks));
    
    // simple encoding (only direct line references)
    Encodings simpleEncodings = mapValues(textIDToLines,
      (IF1<LS, L<Int>>) (lines -> map(lines, line -> lineIndex.get(line))));
    //printAndCheckEncodings(simpleEncodings);
    
    Encodings advancedEncodings = simpleEncodings;
    while licensed {
      Encodings e = compressPairs(advancedEncodings);
      if (e == advancedEncodings) break;
      advancedEncodings = e;
    }

    finalEncodings = advancedEncodings;
    if (verbose || verify) printAndCheckEncodings(finalEncodings);
  }
  
  void saveAsTextFile(File f) {
    S out = exportEncoding(finalEncodings);
    File file = saveTextFile_infoBox(javaxDataDir("Compressed Snippet Version History/versions-of-" + psI(snippetID) + ".linecomp"), out);
    
    if (verify) checkDecompression(file, textIDToLines);
  }
  
  void checkDecompression(File file, Map<S, LS> textIDToLines) {
    temp BufferedReader reader = bufferedUtf8Reader(file);
    LineCompReader lcr = new(reader);
    assertEquals(keysList(textIDToLines), asList(lcr.versions()));
    for (S version : keys(textIDToLines))
      assertEquals(lcr.textForVersion(version), lines_rtrim(textIDToLines.get(version)));
    if (verbose) print("Decompression OK for " + nVersions(textIDToLines));
  }
  
  S exportEncoding(Encodings encodings) {
    new LS buf;
    buf.add("LINECOMP " + primChunks); // magic signature
    for (Chunk c : chunks) {
      if (c cast CPair)
        buf.add(c.i1 + " " + c.i2);
      else
        buf.add(((CPrim) c).s);
    }
    for (S id, L<Int> l : encodings)
      buf.add(id + "=" + joinWithSpace(l));
    ret lines_rtrim(buf);
  }
  
  Encodings compressPairs(Encodings encodings) {
    new MultiSet<Pair<Int>> pairCounts;
    
    for (L<Int> l : values(encodings)) {
      Pair<Int> lastPair = null;
      for (Pair<Int> pair : overlappingPairs(l)) {
        if (neq(pair, lastPair)) {
          lastPair = pair;
          pairCounts.add(pair);
        }
      }
    }
    
    //print("Pair counts: " + pairCounts);
    Pair<Int> toCompress = msMostPopularDuplicate(pairCounts);

    // Compress only most popular pair
    if (toCompress == null) ret encodings; // Nothing to do
    int idx = makeCPair(toCompress);
    print("Made pair: " + toCompress + " -> " + idx + ", " + (msNumberOfDuplicates(pairCounts)-1) + " remaining");
    ret mapValues(encodings, (IF1<L<Int>>) encoded ->
      replaceSublist(encoded, pairToList(toCompress), ll(idx)));
  }
  
  int makeCPair(Pair<Int> p) {
    int idx = addAndReturnIndex(chunks, new CPair(p));
    ret idx;
  }
  
  void printAndCheckEncodings(Encodings encodings) {
    for (S id, L<Int> encoded : encodings) {
      if (verbose) print(id + ": " + joinWithSpace(encoded));
      assertEquals(lines(textIDToLines.get(id)), decode(encoded));
    }
  }
  
  S decode(L<Int> encoded) {
    ret lines(lambdaMap chunkText(encoded));
  }
  
  S chunkText(int idx) {
    ret chunks.get(idx).text(chunks);
  }
}