Remove KV serialiser forward declaration indirection

src/kv/committable_tx.h

@@ -85,7 +85,7 @@ namespace ccf::kv
         entry_flags |= EntryFlags::FORCE_LEDGER_CHUNK_BEFORE;
       }
 
-      KvStoreSerialiser replicated_serialiser(
+      RawKvStoreSerialiser replicated_serialiser(
         e,
         {pimpl->commit_view, version},
         entry_type,

src/kv/generic_serialise_wrapper.h

@@ -13,11 +13,8 @@
 
 namespace ccf::kv
 {
-  using SerialisedKey = ccf::kv::serialisers::SerialisedEntry;
-  using SerialisedValue = ccf::kv::serialisers::SerialisedEntry;
-
   template <typename W>
-  class GenericSerialiseWrapper
+  class GenericSerialiseWrapper : public KvStoreSerialiser
   {
   private:
     W public_writer;
@@ -92,7 +89,7 @@ namespace ccf::kv
       serialise_internal((Version)0u);
     }
 
-    void start_map(const std::string& name, SecurityDomain domain)
+    void start_map(const std::string& name, SecurityDomain domain) override
     {
       if (domain == SecurityDomain::PRIVATE && !crypto_util)
       {
@@ -108,45 +105,46 @@ namespace ccf::kv
       serialise_internal(name);
     }
 
-    void serialise_raw(const std::vector<uint8_t>& raw)
+    void serialise_raw(const std::vector<uint8_t>& raw) override
     {
       serialise_internal(raw);
     }
 
-    void serialise_view_history(const std::vector<Version>& view_history)
+    void serialise_view_history(
+      const std::vector<Version>& view_history) override
     {
       serialise_internal(view_history);
     }
 
-    template <class Version>
-    void serialise_entry_version(const Version& version)
+    void serialise_entry_version(const Version& version) override
     {
       serialise_internal(version);
     }
 
-    void serialise_count_header(uint64_t ctr)
+    void serialise_count_header(uint64_t ctr) override
     {
       serialise_internal(ctr);
     }
 
-    void serialise_read(const SerialisedKey& k, const Version& version)
+    void serialise_read(const SerialisedKey& k, const Version& version) override
     {
       serialise_internal(k);
       serialise_internal(version);
     }
 
-    void serialise_write(const SerialisedKey& k, const SerialisedValue& v)
+    void serialise_write(
+      const SerialisedKey& k, const SerialisedValue& v) override
     {
       serialise_internal(k);
       serialise_internal(v);
     }
 
-    void serialise_remove(const SerialisedKey& k)
+    void serialise_remove(const SerialisedKey& k) override
     {
       serialise_internal(k);
     }
 
-    std::vector<uint8_t> get_raw_data()
+    std::vector<uint8_t> get_raw_data() override
     {
       // make sure the private buffer is empty when we return
       auto writer_guard_func = [](W* writer) { writer->clear(); };
@@ -160,7 +158,7 @@ namespace ccf::kv
     std::vector<uint8_t> serialise_domains(
       const std::vector<uint8_t>& serialised_public_domain,
       const std::vector<uint8_t>& serialised_private_domain =
-        std::vector<uint8_t>())
+        std::vector<uint8_t>()) override
     {
       size_t size_ = serialised_public_domain.size();
 
@@ -238,7 +236,7 @@ namespace ccf::kv
   };
 
   template <typename R>
-  class GenericDeserialiseWrapper
+  class GenericDeserialiseWrapper : public KvStoreDeserialiser
   {
   private:
     R public_reader;
@@ -289,12 +287,13 @@ namespace ccf::kv
       domain_restriction(domain_restriction)
     {}
 
-    ccf::ClaimsDigest&& consume_claims_digest()
+    ccf::ClaimsDigest&& consume_claims_digest() override
     {
       return std::move(claims_digest);
     }
 
     std::optional<ccf::crypto::Sha256Hash>&& consume_commit_evidence_digest()
+      override
     {
       return std::move(commit_evidence_digest);
     }
@@ -304,7 +303,7 @@ namespace ccf::kv
       size_t size,
       ccf::kv::Term& term,
       EntryFlags& flags,
-      bool historical_hint = false)
+      bool historical_hint = false) override
     {
       current_reader = &public_reader;
       const auto* data_ = data;
@@ -389,7 +388,7 @@ namespace ccf::kv
       return version;
     }
 
-    std::optional<std::string> start_map()
+    std::optional<std::string> start_map() override
     {
       if (current_reader->is_eos())
       {
@@ -406,56 +405,56 @@ namespace ccf::kv
       return current_reader->template read_next<std::string>();
     }
 
-    Version deserialise_entry_version()
+    Version deserialise_entry_version() override
     {
       return current_reader->template read_next<Version>();
     }
 
-    uint64_t deserialise_read_header()
+    uint64_t deserialise_read_header() override
     {
       return current_reader->template read_next<uint64_t>();
     }
 
-    std::tuple<SerialisedKey, Version> deserialise_read()
+    std::tuple<SerialisedKey, Version> deserialise_read() override
     {
       return {
         current_reader->template read_next<SerialisedKey>(),
         current_reader->template read_next<Version>()};
     }
 
-    uint64_t deserialise_write_header()
+    uint64_t deserialise_write_header() override
     {
       return current_reader->template read_next<uint64_t>();
     }
 
-    std::tuple<SerialisedKey, SerialisedValue> deserialise_write()
+    std::tuple<SerialisedKey, SerialisedValue> deserialise_write() override
     {
       return {
         current_reader->template read_next<SerialisedKey>(),
         current_reader->template read_next<SerialisedValue>()};
     }
 
-    std::vector<uint8_t> deserialise_raw()
+    std::vector<uint8_t> deserialise_raw() override
     {
       return current_reader->template read_next<std::vector<uint8_t>>();
     }
 
-    std::vector<Version> deserialise_view_history()
+    std::vector<Version> deserialise_view_history() override
     {
       return current_reader->template read_next<std::vector<Version>>();
     }
 
-    uint64_t deserialise_remove_header()
+    uint64_t deserialise_remove_header() override
     {
       return current_reader->template read_next<uint64_t>();
     }
 
-    SerialisedKey deserialise_remove()
+    SerialisedKey deserialise_remove() override
     {
       return current_reader->template read_next<SerialisedKey>();
     }
 
-    bool end()
+    bool end() override
     {
       return current_reader->is_eos() && public_reader.is_eos();
     }

src/kv/kv_serialiser.h

@@ -3,4 +3,10 @@
 
 #pragma once
 
-#include "kv/raw_serialise.h"
+#include "kv/raw_serialise.h"
+
+namespace ccf::kv
+{
+  using RawKvStoreSerialiser = GenericSerialiseWrapper<RawWriter>;
+  using RawKvStoreDeserialiser = GenericDeserialiseWrapper<RawReader>;
+}

src/kv/kv_types.h

@@ -10,6 +10,7 @@
 #include "ccf/entity_id.h"
 #include "ccf/kv/get_name.h"
 #include "ccf/kv/hooks.h"
+#include "ccf/kv/serialisers/serialised_entry.h"
 #include "ccf/kv/version.h"
 #include "ccf/node/cose_signatures_config.h"
 #include "ccf/node/startup_config.h"
@@ -19,16 +20,18 @@
 #include "ccf/tx_status.h"
 #include "crypto/openssl/ec_key_pair.h"
 #include "kv/ledger_chunker_interface.h"
-#include "serialiser_declare.h"
+#include "serialised_entry_format.h"
 
 #include <array>
 #include <chrono>
 #include <functional>
 #include <limits>
 #include <list>
 #include <memory>
+#include <optional>
 #include <set>
 #include <string>
+#include <tuple>
 #include <unordered_set>
 #include <vector>
 
@@ -301,6 +304,58 @@ namespace ccf::kv
     return {security_domain, access_category};
   }
 
+  using SerialisedKey = ccf::kv::serialisers::SerialisedEntry;
+  using SerialisedValue = ccf::kv::serialisers::SerialisedEntry;
+
+  class KvStoreSerialiser
+  {
+  public:
+    virtual ~KvStoreSerialiser() = default;
+
+    virtual void start_map(const std::string& name, SecurityDomain domain) = 0;
+    virtual void serialise_raw(const std::vector<uint8_t>& raw) = 0;
+    virtual void serialise_view_history(
+      const std::vector<Version>& view_history) = 0;
+    virtual void serialise_entry_version(const Version& version) = 0;
+    virtual void serialise_count_header(uint64_t ctr) = 0;
+    virtual void serialise_read(
+      const SerialisedKey& k, const Version& version) = 0;
+    virtual void serialise_write(
+      const SerialisedKey& k, const SerialisedValue& v) = 0;
+    virtual void serialise_remove(const SerialisedKey& k) = 0;
+    virtual std::vector<uint8_t> get_raw_data() = 0;
+    virtual std::vector<uint8_t> serialise_domains(
+      const std::vector<uint8_t>& serialised_public_domain,
+      const std::vector<uint8_t>& serialised_private_domain = {}) = 0;
+  };
+
+  class KvStoreDeserialiser
+  {
+  public:
+    virtual ~KvStoreDeserialiser() = default;
+
+    virtual ccf::ClaimsDigest&& consume_claims_digest() = 0;
+    virtual std::optional<ccf::crypto::Sha256Hash>&&
+    consume_commit_evidence_digest() = 0;
+    virtual std::optional<Version> init(
+      const uint8_t* data,
+      size_t size,
+      ccf::kv::Term& term,
+      EntryFlags& flags,
+      bool historical_hint = false) = 0;
+    virtual std::optional<std::string> start_map() = 0;
+    virtual Version deserialise_entry_version() = 0;
+    virtual uint64_t deserialise_read_header() = 0;
+    virtual std::tuple<SerialisedKey, Version> deserialise_read() = 0;
+    virtual uint64_t deserialise_write_header() = 0;
+    virtual std::tuple<SerialisedKey, SerialisedValue> deserialise_write() = 0;
+    virtual std::vector<uint8_t> deserialise_raw() = 0;
+    virtual std::vector<Version> deserialise_view_history() = 0;
+    virtual uint64_t deserialise_remove_header() = 0;
+    virtual SerialisedKey deserialise_remove() = 0;
+    virtual bool end() = 0;
+  };
+
   enum ApplyResult : uint8_t
   {
     PASS = 1,

src/kv/snapshot.h

@@ -51,7 +51,7 @@ namespace ccf::kv
       // - Because snapshot generation and ledger rekey can be interleaved,
       // consider historical ledger secrets when encrypting snapshot (see
       // https://github.com/microsoft/CCF/issues/3796).
-      KvStoreSerialiser serialiser(
+      RawKvStoreSerialiser serialiser(
         encryptor,
         {0, version},
         ccf::kv::EntryType::Snapshot,

src/kv/store.h

@@ -398,7 +398,7 @@ namespace ccf::kv
       bool public_only = false) override
     {
       auto e = get_encryptor();
-      auto d = KvStoreDeserialiser(
+      auto d = RawKvStoreDeserialiser(
         e,
         public_only ? ccf::kv::SecurityDomain::PUBLIC :
                       std::optional<ccf::kv::SecurityDomain>());
@@ -727,7 +727,7 @@ namespace ccf::kv
       // deserialisation will then fail.
       auto e = get_encryptor();
 
-      auto d = KvStoreDeserialiser(
+      auto d = RawKvStoreDeserialiser(
         e,
         public_only ? ccf::kv::SecurityDomain::PUBLIC :
                       std::optional<ccf::kv::SecurityDomain>());