libutil: Move references.{hh,cc} to libstore

The implicit dependency on refLength (which is the StorePath::HashLen)
is not good. Also the companion tests and benchmarks are already in libstore-tests.

src/libutil/include/nix/util/meson.build

@@ -55,7 +55,6 @@ headers = files(
   'posix-source-accessor.hh',
   'processes.hh',
   'ref.hh',
-  'references.hh',
   'regex-combinators.hh',
   'repair-flag.hh',
   'serialise.hh',

src/libutil/include/nix/util/references.hh

@@ -1,60 +0,0 @@
-#pragma once
-///@file
-
-#include "nix/util/hash.hh"
-
-namespace nix {
-
-class RefScanSink : public Sink
-{
-    StringSet hashes;
-    StringSet seen;
-
-    std::string tail;
-
-public:
-
-    RefScanSink(StringSet && hashes)
-        : hashes(hashes)
-    {
-    }
-
-    StringSet & getResult()
-    {
-        return seen;
-    }
-
-    void operator()(std::string_view data) override;
-};
-
-struct RewritingSink : Sink
-{
-    const StringMap rewrites;
-    std::string::size_type maxRewriteSize;
-    std::string prev;
-    Sink & nextSink;
-    uint64_t pos = 0;
-
-    std::vector<uint64_t> matches;
-
-    RewritingSink(const std::string & from, const std::string & to, Sink & nextSink);
-    RewritingSink(const StringMap & rewrites, Sink & nextSink);
-
-    void operator()(std::string_view data) override;
-
-    void flush();
-};
-
-struct HashModuloSink : AbstractHashSink
-{
-    HashSink hashSink;
-    RewritingSink rewritingSink;
-
-    HashModuloSink(HashAlgorithm ha, const std::string & modulus);
-
-    void operator()(std::string_view data) override;
-
-    HashResult finish() override;
-};
-
-} // namespace nix

src/libutil/meson.build

@@ -145,7 +145,6 @@ sources = [ config_priv_h ] + files(
   'pos-table.cc',
   'position.cc',
   'posix-source-accessor.cc',
-  'references.cc',
   'serialise.cc',
   'signature/local-keys.cc',
   'signature/signer.cc',

src/libutil/references.cc

@@ -1,126 +0,0 @@
-#include "nix/util/references.hh"
-#include "nix/util/hash.hh"
-#include "nix/util/archive.hh"
-#include "nix/util/base-nix-32.hh"
-
-#include <map>
-#include <cstdlib>
-#include <mutex>
-#include <algorithm>
-
-namespace nix {
-
-static size_t refLength = 32; /* characters */
-
-static void search(std::string_view s, StringSet & hashes, StringSet & seen)
-{
-    for (size_t i = 0; i + refLength <= s.size();) {
-        int j;
-        bool match = true;
-        for (j = refLength - 1; j >= 0; --j)
-            if (!BaseNix32::lookupReverse(s[i + j])) {
-                i += j + 1;
-                match = false;
-                break;
-            }
-        if (!match)
-            continue;
-        std::string ref(s.substr(i, refLength));
-        if (hashes.erase(ref)) {
-            debug("found reference to '%1%' at offset '%2%'", ref, i);
-            seen.insert(ref);
-        }
-        ++i;
-    }
-}
-
-void RefScanSink::operator()(std::string_view data)
-{
-    /* It's possible that a reference spans the previous and current
-       fragment, so search in the concatenation of the tail of the
-       previous fragment and the start of the current fragment. */
-    auto s = tail;
-    auto tailLen = std::min(data.size(), refLength);
-    s.append(data.data(), tailLen);
-    search(s, hashes, seen);
-
-    search(data, hashes, seen);
-
-    auto rest = refLength - tailLen;
-    if (rest < tail.size())
-        tail = tail.substr(tail.size() - rest);
-    tail.append(data.data() + data.size() - tailLen, tailLen);
-}
-
-RewritingSink::RewritingSink(const std::string & from, const std::string & to, Sink & nextSink)
-    : RewritingSink({{from, to}}, nextSink)
-{
-}
-
-RewritingSink::RewritingSink(const StringMap & rewrites, Sink & nextSink)
-    : rewrites(rewrites)
-    , nextSink(nextSink)
-{
-    std::string::size_type maxRewriteSize = 0;
-    for (auto & [from, to] : rewrites) {
-        assert(from.size() == to.size());
-        maxRewriteSize = std::max(maxRewriteSize, from.size());
-    }
-    this->maxRewriteSize = maxRewriteSize;
-}
-
-void RewritingSink::operator()(std::string_view data)
-{
-    std::string s(prev);
-    s.append(data);
-
-    s = rewriteStrings(s, rewrites);
-
-    prev = s.size() < maxRewriteSize ? s
-           : maxRewriteSize == 0     ? ""
-                                     : std::string(s, s.size() - maxRewriteSize + 1, maxRewriteSize - 1);
-
-    auto consumed = s.size() - prev.size();
-
-    pos += consumed;
-
-    if (consumed)
-        nextSink(s.substr(0, consumed));
-}
-
-void RewritingSink::flush()
-{
-    if (prev.empty())
-        return;
-    pos += prev.size();
-    nextSink(prev);
-    prev.clear();
-}
-
-HashModuloSink::HashModuloSink(HashAlgorithm ha, const std::string & modulus)
-    : hashSink(ha)
-    , rewritingSink(modulus, std::string(modulus.size(), 0), hashSink)
-{
-}
-
-void HashModuloSink::operator()(std::string_view data)
-{
-    rewritingSink(data);
-}
-
-HashResult HashModuloSink::finish()
-{
-    rewritingSink.flush();
-
-    /* Hash the positions of the self-references. This ensures that a
-       NAR with self-references and a NAR with some of the
-       self-references already zeroed out do not produce a hash
-       collision. FIXME: proof. */
-    for (auto & pos : rewritingSink.matches)
-        hashSink(fmt("|%d", pos));
-
-    auto h = hashSink.finish();
-    return {.hash = h.hash, .numBytesDigested = rewritingSink.pos};
-}
-
-} // namespace nix