map.h

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the Apache 2.0 License.
#pragma once
 
#include "ccf/kv/get_name.h"
#include "ccf/kv/hooks.h"
#include "ccf/kv/map_diff.h"
#include "ccf/kv/map_handle.h"
#include "ccf/kv/serialisers/blit_serialiser.h"
#include "ccf/kv/serialisers/json_serialiser.h"
#include "ccf/kv/untyped.h"
 
namespace ccf::kv
{
  template <typename K, typename V, typename KSerialiser, typename VSerialiser>
  class TypedMap : public GetName
  {
  public:
    // Expose correct public aliases of types
    using ReadOnlyHandle =
      ccf::kv::ReadableMapHandle<K, V, KSerialiser, VSerialiser>;
    using WriteOnlyHandle =
      ccf::kv::WriteableMapHandle<K, V, KSerialiser, VSerialiser>;
    using Handle = ccf::kv::MapHandle<K, V, KSerialiser, VSerialiser>;
    using Diff = ccf::kv::MapDiff<K, V, KSerialiser, VSerialiser>;
 
    using Write = std::map<K, std::optional<V>>;
    using CommitHook = CommitHook<Write>;
    using MapHook = MapHook<Write>;
 
    using Key = K;
    using Value = V;
    using KeySerialiser = KSerialiser;
    using ValueSerialiser = VSerialiser;
 
    using GetName::GetName;
 
  private:
    static Write deserialise_write(const ccf::kv::untyped::Write& w)
    {
      Write typed_writes;
      for (const auto& [uk, opt_uv] : w)
      {
        if (!opt_uv.has_value())
        {
          // Deletions are indicated by nullopt. We cannot deserialise them,
          // they are deletions here as well
          typed_writes[KSerialiser::from_serialised(uk)] = std::nullopt;
        }
        else
        {
          typed_writes[KSerialiser::from_serialised(uk)] =
            VSerialiser::from_serialised(opt_uv.value());
        }
      }
      return typed_writes;
    }
 
  public:
    static ccf::kv::untyped::CommitHook wrap_commit_hook(const CommitHook& hook)
    {
      return [hook](Version v, const ccf::kv::untyped::Write& w) {
        hook(v, deserialise_write(w));
      };
    }
 
    static ccf::kv::untyped::MapHook wrap_map_hook(const MapHook& hook)
    {
      return [hook](Version v, const ccf::kv::untyped::Write& w) {
        return hook(v, deserialise_write(w));
      };
    }
  };
 
  template <
    typename K,
    typename V,
    template <typename>
    typename KSerialiser,
    template <typename> typename VSerialiser = KSerialiser>
  using MapSerialisedWith = TypedMap<K, V, KSerialiser<K>, VSerialiser<V>>;
 
  template <typename K, typename V>
  using JsonSerialisedMap =
    MapSerialisedWith<K, V, ccf::kv::serialisers::JsonSerialiser>;
 
  template <typename K, typename V>
  using RawCopySerialisedMap = TypedMap<
    K,
    V,
    ccf::kv::serialisers::BlitSerialiser<K>,
    ccf::kv::serialisers::BlitSerialiser<V>>;
 
  template <typename K, typename V>
  using Map = JsonSerialisedMap<K, V>;
}