map_handle.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/untyped_map_handle.h"
 
namespace ccf::kv
{
  template <typename K, typename V, typename KSerialiser, typename VSerialiser>
  class ReadableMapHandle
  {
  protected:
    ccf::kv::untyped::MapHandle& read_handle;
 
  public:
    using KeyType = K;
    using ValueType = V;
 
    ReadableMapHandle(ccf::kv::untyped::MapHandle& uh) : read_handle(uh) {}
 
    std::string get_name_of_map() const
    {
      return read_handle.get_name_of_map();
    }
 
    std::optional<V> get(const K& key)
    {
      const auto opt_v_rep = read_handle.get(KSerialiser::to_serialised(key));
 
      if (opt_v_rep.has_value())
      {
        return VSerialiser::from_serialised(*opt_v_rep);
      }
 
      return std::nullopt;
    }
 
    std::optional<V> get_globally_committed(const K& key)
    {
      const auto opt_v_rep =
        read_handle.get_globally_committed(KSerialiser::to_serialised(key));
 
      if (opt_v_rep.has_value())
      {
        return VSerialiser::from_serialised(*opt_v_rep);
      }
 
      return std::nullopt;
    }
 
    bool has(const K& key)
    {
      return read_handle.has(KSerialiser::to_serialised(key));
    }
 
    std::optional<Version> get_version_of_previous_write(const K& key)
    {
      return read_handle.get_version_of_previous_write(
        KSerialiser::to_serialised(key));
    }
 
    template <class F>
    void foreach(F&& f)
    {
      auto g = [&](
                 const ccf::kv::serialisers::SerialisedEntry& k_rep,
                 const ccf::kv::serialisers::SerialisedEntry& v_rep) {
        return f(
          KSerialiser::from_serialised(k_rep),
          VSerialiser::from_serialised(v_rep));
      };
      read_handle.foreach(g);
    }
 
    template <class F>
    void foreach_key(F&& f)
    {
      auto g = [&](
                 const ccf::kv::serialisers::SerialisedEntry& k_rep,
                 const ccf::kv::serialisers::SerialisedEntry&) {
        return f(KSerialiser::from_serialised(k_rep));
      };
      read_handle.foreach(g);
    }
 
    template <class F>
    void foreach_value(F&& f)
    {
      auto g = [&](
                 const ccf::kv::serialisers::SerialisedEntry&,
                 const ccf::kv::serialisers::SerialisedEntry& v_rep) {
        return f(VSerialiser::from_serialised(v_rep));
      };
      read_handle.foreach(g);
    }
 
    size_t size()
    {
      return read_handle.size();
    }
  };
 
  template <typename K, typename V, typename KSerialiser, typename VSerialiser>
  class WriteableMapHandle
  {
  protected:
    ccf::kv::untyped::MapHandle& write_handle;
 
  public:
    WriteableMapHandle(ccf::kv::untyped::MapHandle& uh) : write_handle(uh) {}
 
    void put(const K& key, const V& value)
    {
      write_handle.put(
        KSerialiser::to_serialised(key), VSerialiser::to_serialised(value));
    }
 
    void remove(const K& key)
    {
      write_handle.remove(KSerialiser::to_serialised(key));
    }
 
    void clear()
    {
      write_handle.clear();
    }
  };
 
  template <typename K, typename V, typename KSerialiser, typename VSerialiser>
  class MapHandle : public AbstractHandle,
                    public ReadableMapHandle<K, V, KSerialiser, VSerialiser>,
                    public WriteableMapHandle<K, V, KSerialiser, VSerialiser>
  {
  protected:
    ccf::kv::untyped::MapHandle untyped_handle;
 
    using ReadableBase = ReadableMapHandle<K, V, KSerialiser, VSerialiser>;
    using WriteableBase = WriteableMapHandle<K, V, KSerialiser, VSerialiser>;
 
  public:
    MapHandle(
      ccf::kv::untyped::ChangeSet& changes, const std::string& map_name) :
      ReadableBase(untyped_handle),
      WriteableBase(untyped_handle),
      untyped_handle(changes, map_name)
    {}
  };
}