map_diff.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_diff.h"
 
namespace ccf::kv
{
  template <typename K, typename V, typename KSerialiser, typename VSerialiser>
  class MapDiff : public AbstractHandle
  {
  protected:
    ccf::kv::untyped::MapDiff map_diff;
 
  public:
    using KeyType = K;
    using ValueType = V;
 
    MapDiff(ccf::kv::untyped::MapDiff map_diff_) : map_diff(map_diff_) {}
 
    MapDiff(ccf::kv::untyped::ChangeSet& changes, const std::string& map_name) :
      map_diff(changes, map_name)
    {}
 
    std::optional<std::optional<V>> get(const K& key)
    {
      const auto opt_v_rep = map_diff.get(KSerialiser::to_serialised(key));
 
      if (opt_v_rep.has_value())
      {
        if (opt_v_rep.value().has_value())
        {
          return VSerialiser::from_serialised(opt_v_rep.value().value());
        }
      }
 
      return std::nullopt;
    }
 
    bool has(const K& key)
    {
      return map_diff.has(KSerialiser::to_serialised(key));
    }
 
    bool is_deleted(const K& key)
    {
      return map_diff.is_deleted(KSerialiser::to_serialised(key));
    }
 
    template <class F>
    void foreach(F&& f)
    {
      const auto& g =
        [&](
          const ccf::kv::serialisers::SerialisedEntry& k_rep,
          const std::optional<ccf::kv::serialisers::SerialisedEntry>& v_rep)
        -> bool {
        const auto k = KSerialiser::from_serialised(k_rep);
        if (v_rep.has_value())
        {
          const std::optional<V> v =
            VSerialiser::from_serialised(v_rep.value());
          return f(k, v);
        }
        else
        {
          const std::optional<V> v = std::nullopt;
          return f(k, v);
        }
      };
      map_diff.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));
      };
      map_diff.foreach(g);
    }
 
    template <class F>
    void foreach_value(F&& f)
    {
      auto g =
        [&](
          const ccf::kv::serialisers::SerialisedEntry&,
          const std::optional<ccf::kv::serialisers::SerialisedEntry>& v_rep) {
          if (v_rep.has_value())
          {
            return f(VSerialiser::from_serialised(v_rep));
          }
          else
          {
            return f(std::nullopt);
          }
        };
      map_diff.foreach(g);
    }
 
    size_t size()
    {
      return map_diff.size();
    }
  };
}