serializer.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/ds/nonstd.h"
#include "serialized.h"
 
#include <memory>
#include <span>
#include <tuple>
#include <type_traits>
#include <vector>
 
namespace serializer
{
  // A Serializer is generally used as a template argument. It should provide:
  // - serialize(...): returning a tuple of PartialSerializations representing
  //   all passed args. It may be templated and variadic or accept only precise
  //   argument types. Ideally it should give a useful error message at compile
  //   time when called with argument types it doesn't support.
  // - deserialize(const uint8_t* data, size_t size): returning a tuple of
  //   elements parsed from byte buffer, potentially throwing logic errors if
  //   anything is missing/malformed. May need to be templated on expected
  //   types.
 
  struct ByteRange
  {
    const uint8_t* data;
    const size_t size;
 
    operator std::span<const uint8_t>() const
    {
      return {data, size};
    }
  };
 
  namespace details
  {
    template <size_t I = 0, typename F, typename... Ts>
    static auto tuple_apply(const std::tuple<Ts...>& t, const F& f)
    {
      if constexpr (sizeof...(Ts) == 1)
      {
        return std::make_tuple();
      }
      else if constexpr (I == sizeof...(Ts) - 1)
      {
        return f(std::get<I>(t));
      }
      else
      {
        return std::tuple_cat(f(std::get<I>(t)), tuple_apply<I + 1>(t, f));
      }
    }
 
    template <typename Tup>
    struct TupMatcher
    {
      static constexpr size_t TupSize = std::tuple_size_v<Tup>;
 
      template <typename... Ts>
      struct correct_size
      {
        static constexpr bool value = TupSize == sizeof...(Ts);
      };
 
      template <typename... Ts>
      static constexpr bool correct_size_v = correct_size<Ts...>::value;
 
      template <size_t I, typename T>
      struct close_enough_at
      {
        using CanonTarget =
          std::remove_cvref_t<typename std::tuple_element_t<I, Tup>>;
        using CanonArgument = std::remove_cvref_t<T>;
 
        // This determines what types a Serializer will accept as arguments to
        // serialize(...), relative to the declared param types.
        // The main feature is the removal of const, volatile, and references
        // from the type so that a Serializer<int> will accept an argument of
        // type const int&.
        // Additionally, this will accept ByteRange arguments for parameters
        // declared as std::vector<uint8_t> and vice versa - when serializing we
        // can copy bytes from either in the same way, but there is a
        // distinction in the deserialized type of whether we are copying (to a
        // byte vector) or referring to an existing byte range. It may be
        // possible to generalise this further and replace with
        // std::is_constructible, but these restrictions are sufficient for the
        // current uses.
        // Additionally again, this will accept an array-like of ByteRanges for
        // a single ByteRange parameter. These will be serialised in-order, and
        // produce a single ByteRange in deserialisation.
        static constexpr bool value =
          std::is_same_v<CanonTarget, CanonArgument> ||
          (std::is_same_v<CanonTarget, std::vector<uint8_t>> &&
           std::is_same_v<CanonArgument, ByteRange>) ||
          (std::is_same_v<CanonTarget, ByteRange> &&
           std::is_same_v<CanonArgument, std::vector<uint8_t>>) ||
          (std::is_same_v<CanonTarget, ByteRange> &&
           (std::is_array_v<CanonArgument> &&
            std::is_same_v<std::remove_extent_t<CanonArgument>, ByteRange>));
      };
 
      // Only reached when Ts is empty
      template <size_t I, typename... Ts>
      struct close_enough_from
      {
        static constexpr bool value = I == TupSize;
      };
 
      template <size_t I, typename T, typename... Ts>
      struct close_enough_from<I, T, Ts...>
      {
        static constexpr bool value = close_enough_at<I, T>::value &&
          close_enough_from<I + 1, Ts...>::value;
      };
 
      template <typename... Ts>
      struct close_enough
      {
        static constexpr bool value = close_enough_from<0, Ts...>::value;
      };
 
      template <typename... Ts>
      static constexpr bool close_enough_v = close_enough<Ts...>::value;
    };
 
    template <typename... Ts>
    struct TypeMatcher : public TupMatcher<std::tuple<Ts...>>
    {};
  }
 
  struct AbstractSerializedSection
  {
    virtual ~AbstractSerializedSection() = default;
    [[nodiscard]] virtual const uint8_t* data() const = 0;
    [[nodiscard]] virtual size_t size() const = 0;
  };
 
  using PartialSerialization = std::shared_ptr<AbstractSerializedSection>;
 
  template <typename T>
  struct CopiedSection : public AbstractSerializedSection
  {
    const T t;
 
    CopiedSection(const T& t_) : t(t_) {}
 
    [[nodiscard]] const uint8_t* data() const override
    {
      return reinterpret_cast<const uint8_t*>(&t);
    }
 
    [[nodiscard]] size_t size() const override
    {
      return sizeof(T);
    }
  };
 
  template <typename T>
  struct RawSection : public AbstractSerializedSection
  {
    const T& t;
 
    RawSection(const T& t_) : t(t_) {}
 
    [[nodiscard]] const uint8_t* data() const override
    {
      return reinterpret_cast<const uint8_t*>(&t);
    }
 
    [[nodiscard]] size_t size() const override
    {
      return sizeof(T);
    }
  };
 
  struct MemoryRegionSection : public AbstractSerializedSection
  {
    const uint8_t* const d;
    const size_t s;
 
    MemoryRegionSection(const uint8_t* data_, size_t size_) : d(data_), s(size_)
    {}
 
    [[nodiscard]] const uint8_t* data() const override
    {
      return d;
    }
 
    [[nodiscard]] size_t size() const override
    {
      return s;
    }
  };
 
  class EmptySerializer
  {
  public:
    template <typename... Ts>
    static std::tuple<> serialize(const Ts&... ts)
    {
      static_assert(
        sizeof...(ts) == 0,
        "EmptySerializer was given message payload to serialize - can only "
        "serialize empty "
        "messages");
      return std::make_tuple();
    }
 
    template <typename... Ts>
    static std::tuple<> deserialize(const uint8_t* /*unused*/, size_t size)
    {
      if constexpr (sizeof...(Ts) == 0)
      {
        if (size > 0)
        {
          throw std::logic_error(
            "EmptySerializer asked to deserialize buffer of size " +
            std::to_string(size) + ", should be empty");
        }
      }
      return std::make_tuple();
    }
  };
 
  class CommonSerializer : public EmptySerializer
  {
    template <size_t N, size_t... Is>
    static auto serialize_byte_range_with_index_sequence(
      const ByteRange (&brs)[N], std::index_sequence<Is...> /*unused*/)
    {
      return std::make_tuple(
        std::make_shared<MemoryRegionSection>(brs[Is].data, brs[Is].size)...);
    }
 
    static auto serialize_value(const ByteRange& br)
    {
      auto cs = std::make_shared<CopiedSection<size_t>>(br.size);
      auto bfs = std::make_shared<MemoryRegionSection>(br.data, br.size);
      return std::tuple_cat(std::make_tuple(cs), std::make_tuple(bfs));
    }
 
    template <size_t N>
    static auto serialize_value(const ByteRange (&brs)[N])
    {
      return serialize_byte_range_with_index_sequence(
        brs, std::make_index_sequence<N>{});
    }
 
    static auto serialize_value(const std::vector<uint8_t>& vec)
    {
      auto cs = std::make_shared<CopiedSection<size_t>>(vec.size());
      auto bfs = std::make_shared<MemoryRegionSection>(vec.data(), vec.size());
      return std::tuple_cat(std::make_tuple(cs), std::make_tuple(bfs));
    }
 
    static auto serialize_value(std::span<uint8_t> s)
    {
      auto csd = std::make_shared<CopiedSection<uintptr_t>>(
        reinterpret_cast<std::uintptr_t>(s.data()));
      auto css = std::make_shared<CopiedSection<size_t>>(s.size());
      return std::tuple_cat(std::make_tuple(csd), std::make_tuple(css));
    }
 
    static auto serialize_value(const std::string& s)
    {
      auto cs = std::make_shared<CopiedSection<size_t>>(s.size());
      auto bfs = std::make_shared<MemoryRegionSection>(
        reinterpret_cast<const uint8_t*>(s.data()), s.size());
      return std::tuple_cat(std::make_tuple(cs), std::make_tuple(bfs));
    }
 
    template <typename T>
      requires(std::is_integral_v<T> || std::is_enum_v<T>)
    static auto serialize_value(const T& t)
    {
      auto rs = std::make_shared<RawSection<T>>(t);
      return std::make_tuple(rs);
    }
 
    static auto serialize_value_final(const ByteRange& br)
    {
      auto bfs = std::make_shared<MemoryRegionSection>(br.data, br.size);
      return std::make_tuple(bfs);
    }
 
    static auto serialize_value_final(const std::vector<uint8_t>& vec)
    {
      auto bfs = std::make_shared<MemoryRegionSection>(vec.data(), vec.size());
      return std::make_tuple(bfs);
    }
 
    template <typename T>
    static auto serialize_value_final(const T& t)
    {
      return serialize_value(t);
    }
 
    template <typename T>
    struct Tag
    {
      using type = T;
    };
 
    static ByteRange deserialize_value(
      const uint8_t*& data, size_t& size, const Tag<ByteRange>& /*unused*/)
    {
      const auto prefixed_size = serialized::read<size_t>(data, size);
      ByteRange br{data, prefixed_size};
      serialized::skip(data, size, prefixed_size);
      return br;
    }
 
    static std::vector<uint8_t> deserialize_value(
      const uint8_t*& data,
      size_t& size,
      const Tag<std::vector<uint8_t>>& /*unused*/)
    {
      const auto prefixed_size = serialized::read<size_t>(data, size);
      return serialized::read(data, size, prefixed_size);
    }
 
    static std::span<uint8_t> deserialize_value(
      const uint8_t*& data,
      size_t& size,
      const Tag<std::span<uint8_t>>& /*unused*/)
    {
      const auto ptr = serialized::read<uintptr_t>(data, size);
      const auto s = serialized::read<size_t>(data, size);
      return {reinterpret_cast<uint8_t*>(ptr), s};
    }
 
    static std::string deserialize_value(
      const uint8_t*& data, size_t& size, const Tag<std::string>& /*unused*/)
    {
      return serialized::read<std::string>(data, size);
    }
 
    template <typename T>
      requires(std::is_integral_v<T> || std::is_enum_v<T>)
    static T deserialize_value(
      const uint8_t*& data, size_t& size, const Tag<T>& /*unused*/)
    {
      return serialized::read<T>(data, size);
    }
 
    static auto deserialize_value_final(
      const uint8_t*& data, size_t& size, const Tag<ByteRange>& /*unused*/)
    {
      ByteRange br{data, size};
      serialized::skip(data, size, size);
      return br;
    }
 
    static auto deserialize_value_final(
      const uint8_t*& data,
      size_t& size,
      const Tag<std::vector<uint8_t>>& /*unused*/)
    {
      return serialized::read(data, size, size);
    }
 
    template <typename T>
    static T deserialize_value_final(
      const uint8_t*& data, size_t& size, const Tag<T>& tag)
    {
      return deserialize_value(data, size, tag);
    }
 
    template <typename T, typename... Ts>
    static auto deserialize_impl(const uint8_t* data, size_t size)
    {
      using StrippedT = std::remove_cvref_t<T>;
 
      if constexpr (sizeof...(Ts) == 0)
      {
        return std::make_tuple(
          deserialize_value_final(data, size, Tag<StrippedT>{}));
      }
      else
      {
        const auto next =
          std::make_tuple(deserialize_value(data, size, Tag<StrippedT>{}));
        return std::tuple_cat(next, deserialize_impl<Ts...>(data, size));
      }
    }
 
  public:
    // Can also serialize empty messages
    using EmptySerializer::serialize;
 
    template <typename T, typename... Ts>
    static auto serialize(T&& t, Ts&&... ts)
    {
      if constexpr (sizeof...(Ts) == 0)
      {
        return serialize_value_final(std::forward<T>(t));
      }
      else
      {
        const auto next = serialize_value(std::forward<T>(t));
        return std::tuple_cat(next, serialize(std::forward<Ts>(ts)...));
      }
    }
 
    template <typename... Ts>
    static auto deserialize(const uint8_t* data, size_t size)
    {
      if constexpr (sizeof...(Ts) == 0)
      {
        return EmptySerializer::deserialize(data, size);
      }
      else
      {
        return deserialize_impl<Ts...>(data, size);
      }
    }
  };
 
  // Serializes a list of exactly these argument types, and nothing else
  template <typename... Us>
  class PreciseSerializer : private CommonSerializer
  {
    using Matcher = details::TypeMatcher<Us...>;
 
  public:
    template <typename... Ts>
    static auto serialize(Ts&&... ts)
    {
      static_assert(
        Matcher::template correct_size_v<Ts...>,
        "Incorrect number of arguments for PreciseSerializer");
      static_assert(
        Matcher::template close_enough_v<Ts...>,
        "Incorrect type of arguments for PreciseSerializer");
 
      return CommonSerializer::serialize(std::forward<Ts>(ts)...);
    }
 
    template <typename... Ts>
    static auto deserialize(const uint8_t* data, size_t size)
    {
      static_assert(
        Matcher::template correct_size_v<Ts...>,
        "Incorrect number of results for PreciseSerializer");
      static_assert(
        Matcher::template close_enough_v<Ts...>,
        "Incorrect type of results for PreciseSerializer");
 
      return CommonSerializer::deserialize<Us...>(data, size);
    }
 
    static auto deserialize(const uint8_t* data, size_t size)
    {
      return CommonSerializer::deserialize<Us...>(data, size);
    }
  };
 
  template <typename>
  class TupleSerializer;
 
  // Specializes a specific tuple-type only. Removes ref and const when
  // comparing types, ie tuple<int, const float&> will be accepted by
  // TupleSerializers specialized at tuple<int, float>, tuple<const int&, const
  // float&> etc
  template <typename... Us>
  class TupleSerializer<std::tuple<Us...>> : private CommonSerializer
  {
    using Tup = std::tuple<Us...>;
    using Matcher = details::TupMatcher<Tup>;
 
  public:
    template <typename... Ts>
    static auto serialize(std::tuple<Ts...>&& t)
    {
      static_assert(
        Matcher::template correct_size_v<Ts...>,
        "Incorrect tuple size for TupleSerializer");
      static_assert(
        Matcher::template close_enough_v<Ts...>,
        "Incorrect tuple type for TupleSerializer");
 
      return details::tuple_apply(
        t, [](const auto& e) { return CommonSerializer::serialize(e); });
    }
 
    // Takes variadic arguments list, they don't need to be packed in tuple
    template <typename... Ts>
    static auto serialize(Ts&&... ts)
    {
      static_assert(
        Matcher::template correct_size_v<Ts...>,
        "Incorrect number of args for unpacked TupleSerializer");
      static_assert(
        Matcher::template close_enough_v<Ts...>,
        "Incorrect arg types for unpacked TupleSerializer");
 
      return CommonSerializer::serialize(std::forward<Ts>(ts)...);
    }
 
    template <typename... Ts>
    static auto deserialize(const uint8_t* data, size_t size)
    {
      static_assert(
        Matcher::template correct_size_v<Ts...>,
        "Incorrect number of results for TupleSerializer");
      static_assert(
        Matcher::template close_enough_v<Ts...>,
        "Incorrect type of results for TupleSerializer");
 
      return CommonSerializer::deserialize<Ts...>(data, size);
    }
 
    static auto deserialize(const uint8_t* data, size_t size)
    {
      return CommonSerializer::deserialize<Us...>(data, size);
    }
  };
} // namespace serializer