src/lib/fidl/cpp/include/lib/fidl/cpp/internal/natural_types.h - fuchsia - Git at Google

 // Copyright 2021 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #ifndef SRC_LIB_FIDL_CPP_INCLUDE_LIB_FIDL_CPP_INTERNAL_NATURAL_TYPES_H_
 #define SRC_LIB_FIDL_CPP_INCLUDE_LIB_FIDL_CPP_INTERNAL_NATURAL_TYPES_H_

 #include <lib/fidl/cpp/natural_coding_traits.h>
 #include <lib/fidl/cpp/natural_encoder.h>
 #include <lib/fidl/llcpp/message.h>
 #include <lib/fidl/llcpp/wire_types.h>
 #include <lib/fitx/result.h>
 #include <lib/stdcompat/type_traits.h>
 #include <zircon/fidl.h>

 #include <algorithm>
 #include <cstdint>
 #include <utility>
 #include <variant>

 // # Natural domain objects
 //
 // This header contains forward definitions that are part of natural domain
 // objects. The code generator should populate the implementation by generating
 // template specializations for each FIDL data type.
 namespace fidl {

 // |Error| is a type alias for when the result of an operation is an error.
 using Error = Status;

 namespace internal {

 class NaturalEncoder;

 template <typename Constraint, typename Field>
 void NaturalEnvelopeEncode(NaturalEncoder* encoder, Field* value, size_t offset,
                            size_t recursion_depth) {
   if (value == nullptr) {
     // Nothing to encode.
     return;
   }

   const size_t length_before = encoder->CurrentLength();
   const size_t handles_before = encoder->CurrentHandleCount();

   if (::fidl::internal::NaturalEncodingInlineSize<Field, Constraint>(encoder) <=
       FIDL_ENVELOPE_INLINING_SIZE_THRESHOLD) {
     fidl::internal::NaturalEncode<Constraint>(encoder, value, offset, recursion_depth);

     // Call GetPtr after Encode because the buffer may move.
     fidl_envelope_v2_t* envelope = encoder->GetPtr<fidl_envelope_v2_t>(offset);
     envelope->num_handles = static_cast<uint16_t>(encoder->CurrentHandleCount() - handles_before);
     envelope->flags = FIDL_ENVELOPE_FLAGS_INLINING_MASK;
     return;
   }

   fidl::internal::NaturalEncode<Constraint>(
       encoder, value,
       encoder->Alloc(::fidl::internal::NaturalEncodingInlineSize<Field, Constraint>(encoder)),
       recursion_depth);

   // Call GetPtr after Encode because the buffer may move.
   fidl_envelope_v2_t* envelope = encoder->GetPtr<fidl_envelope_v2_t>(offset);
   envelope->num_bytes = static_cast<uint32_t>(encoder->CurrentLength() - length_before);
   envelope->num_handles = static_cast<uint16_t>(encoder->CurrentHandleCount() - handles_before);
   envelope->flags = 0;
 }

 template <typename Constraint, typename Field>
 void NaturalEnvelopeEncodeOptional(NaturalEncoder* encoder, std::optional<Field>* value,
                                    size_t offset, size_t recursion_depth) {
   if (!value->has_value()) {
     // Nothing to encode.
     return;
   }
   NaturalEnvelopeEncode<Constraint>(encoder, &value->value(), offset, recursion_depth);
 }

 template <typename Constraint, typename Field>
 void NaturalEnvelopeDecode(NaturalDecoder* decoder, Field* value, size_t offset,
                            size_t recursion_depth) {
   size_t body_size = NaturalDecodingInlineSize<Field, Constraint>(decoder);
   const size_t length_before = decoder->CurrentLength();
   const size_t handles_before = decoder->CurrentHandleCount();

   fidl_envelope_v2_t* envelope = decoder->GetPtr<fidl_envelope_v2_t>(offset);
   if (::fidl::internal::NaturalDecodingInlineSize<Field, Constraint>(decoder) <=
       FIDL_ENVELOPE_INLINING_SIZE_THRESHOLD) {
     if (envelope->flags != FIDL_ENVELOPE_FLAGS_INLINING_MASK) {
       decoder->SetError(kCodingErrorInvalidInlineBit);
       return;
     }

     fidl::internal::NaturalDecode<Constraint>(
         decoder, value, decoder->GetOffset(&envelope->inline_value), recursion_depth);

     if (decoder->CurrentHandleCount() != handles_before + envelope->num_handles) {
       decoder->SetError(kCodingErrorInvalidNumHandlesSpecifiedInEnvelope);
     }

     uint32_t padding;
     switch (::fidl::internal::NaturalDecodingInlineSize<Field, Constraint>(decoder)) {
       case 1:
         padding = 0xffffff00;
         break;
       case 2:
         padding = 0xffff0000;
         break;
       case 3:
         padding = 0xff000000;
         break;
       case 4:
         padding = 0x00000000;
         break;
       default:
         __builtin_unreachable();
     }
     if ((*decoder->GetPtr<uint32_t>(offset) & padding) != 0) {
       decoder->SetError(kCodingErrorInvalidPaddingBytes);
     }

     return;
   }

   if (envelope->flags != 0) {
     decoder->SetError(kCodingErrorInvalidInlineBit);
     return;
   }

   size_t body_offset;
   if (!decoder->Alloc(body_size, &body_offset)) {
     return;
   }
   fidl::internal::NaturalDecode<Constraint>(decoder, value, body_offset, recursion_depth);

   if (decoder->CurrentHandleCount() != handles_before + envelope->num_handles) {
     decoder->SetError(kCodingErrorInvalidNumHandlesSpecifiedInEnvelope);
   }
   if (decoder->CurrentLength() != length_before + envelope->num_bytes) {
     decoder->SetError(kCodingErrorInvalidNumBytesSpecifiedInEnvelope);
   }
 }

 template <typename Constraint, typename Field>
 void NaturalEnvelopeDecodeOptional(NaturalDecoder* decoder, std::optional<Field>* value,
                                    size_t offset, size_t recursion_depth) {
   fidl_envelope_v2_t* envelope = decoder->GetPtr<fidl_envelope_v2_t>(offset);
   if (*reinterpret_cast<const void* const*>(envelope) == nullptr) {
     value->reset();
     return;
   }
   value->emplace(DefaultConstructPossiblyInvalidObject<Field>::Make());
   NaturalEnvelopeDecode<Constraint>(decoder, &value->value(), offset, recursion_depth);
 }

 // MemberVisitor provides helpers to invoke visitor functions over natural struct and natural table
 // members. This works because structs and tables have similar shapes in the natural bindings.
 // There is an instance data member called `storage_` which is a struct containing the member data
 // and a constexpr std::tuple member called `kMembers`, and each member of that has a `member_ptr`
 // which is a member pointer into the `storage_` struct.
 template <typename T>
 struct MemberVisitor {
   static constexpr auto kMembers = T::kMembers;
   static constexpr size_t kNumMembers = std::tuple_size_v<decltype(kMembers)>;

   // Visit each of the members in order while the visitor function returns a truthy value.
   template <typename U, typename Fn, size_t I = 0>
   static void VisitWhile(U value, Fn func) {
     static_assert(std::is_same_v<T*, U> || std::is_same_v<const T*, U>);
     if constexpr (I < kNumMembers) {
       auto& member_info = std::get<I>(kMembers);
       auto* member_ptr = &(value->storage_.*(member_info.member_ptr));

       if (func(member_ptr, member_info)) {
         VisitWhile<U, Fn, I + 1>(value, func);
       }
     }
   }

   // Visit all of the members in order.
   template <typename U, typename Fn>
   static void Visit(U value, Fn func) {
     static_assert(std::is_same_v<T*, U> || std::is_same_v<const T*, U>);
     VisitWhile(value, [func = std::move(func)](auto member_ptr, auto member_info) {
       func(member_ptr, member_info);
       return true;
     });
   }

   // Visit each of the members of two structs or tables in order while the visitor function returns
   // a truthy value.
   template <typename U, typename Fn, size_t I = 0>
   static void Visit2While(U value1, U value2, Fn func) {
     static_assert(std::is_same_v<T*, U> || std::is_same_v<const T*, U>);
     if constexpr (I < std::tuple_size_v<decltype(T::kMembers)>) {
       auto& member_info = std::get<I>(T::kMembers);
       auto* member_ptr1 = &(value1->storage_.*(member_info.member_ptr));
       auto* member_ptr2 = &(value2->storage_.*(member_info.member_ptr));

       if (func(member_ptr1, member_ptr2, member_info)) {
         Visit2While<U, Fn, I + 1>(value1, value2, func);
       }
     }
   }

   // Visit all of the members of two structs or tables in order.
   template <typename U, typename Fn>
   static void Visit2(U value1, U value2, Fn func) {
     static_assert(std::is_same_v<T*, U> || std::is_same_v<const T*, U>);
     Visit2While(value1, value2,
                 [func = std::move(func)](auto member1, auto member2, auto member_info) {
                   func(member1, member2, member_info);
                   return true;
                 });
   }
 };

 // This holds metadata about a struct member: a member pointer to the member's value in
 // the struct's Storage_ type, offsets, and optionally handle information.
 template <typename T, typename Field_, typename Constraint_>
 struct NaturalStructMember final {
   using Field = Field_;
   using Constraint = Constraint_;
   Field T::*member_ptr;
   size_t offset;
   explicit constexpr NaturalStructMember(Field T::*member_ptr, size_t offset) noexcept
       : member_ptr(member_ptr), offset(offset) {}
 };

 struct TupleVisitor {
  public:
   // Returns true iff the |func| is satified on all items of |tuple|.
   //
   // e.g. TupleVisitor::All(std::make_tuple(1, 2, 3), [](int v) { return v > 0; })
   // returns true because 1, 2, 3 are all > 0.
   template <typename Tuple, typename Fn, size_t I = 0>
   static constexpr auto All(Tuple tuple, Fn func) {
     if constexpr (I == std::tuple_size_v<Tuple>) {
       return true;
     } else {
       return func(std::get<I>(tuple)) && All<Tuple, Fn, I + 1>(tuple, func);
     }
   }
 };

 template <typename MaskType>
 struct NaturalStructPadding final {
   // Offset within the struct (start of struct = 0).
   size_t offset;
   MaskType mask;

   [[nodiscard]] bool ValidatePadding(NaturalDecoder* decoder, size_t base_offset) {
     return (*decoder->GetPtr<MaskType>(base_offset + offset) & mask) == 0;
   }
 };

 template <typename T, size_t Size>
 struct NaturalStructCodingTraits {
   static constexpr size_t inline_size_v2 = Size;
   // True iff all fields are memcpy compatible.
   static constexpr bool are_members_memcpy_compatible =
       TupleVisitor::All(T::kMembers, [](auto member_info) {
         using Field = typename std::remove_reference_t<decltype(member_info)>::Field;
         using Constraint = typename std::remove_reference_t<decltype(member_info)>::Constraint;
         return NaturalIsMemcpyCompatible<Field, Constraint>();
       });
   // True iff fields are memcpy compatible and there is no padding.
   static constexpr bool is_memcpy_compatible =
       are_members_memcpy_compatible && std::tuple_size_v<decltype(T::kPadding)> == 0;

   static void Encode(NaturalEncoder* encoder, T* value, size_t offset, size_t recursion_depth) {
     if constexpr (is_memcpy_compatible) {
       memcpy(encoder->GetPtr<T>(offset), value, sizeof(T));
     } else {
       MemberVisitor<T>::Visit(value, [&](auto* member, auto& member_info) -> void {
         using Constraint = typename std::remove_reference_t<decltype(member_info)>::Constraint;
         fidl::internal::NaturalEncode<Constraint>(encoder, member, offset + member_info.offset,
                                                   recursion_depth);
       });
     }
   }

   static void Decode(NaturalDecoder* decoder, T* value, size_t offset, size_t recursion_depth) {
     if constexpr (is_memcpy_compatible) {
       memcpy(value, decoder->GetPtr<T>(offset), sizeof(T));
     } else {
       MemberVisitor<T>::Visit(value, [&](auto* member, auto& member_info) {
         using Constraint = typename std::remove_reference_t<decltype(member_info)>::Constraint;
         fidl::internal::NaturalDecode<Constraint>(decoder, member, offset + member_info.offset,
                                                   recursion_depth);
       });

       auto valid_padding_predicate = [decoder, offset](auto padding) {
         return padding.ValidatePadding(decoder, offset);
       };
       bool padding_valid = TupleVisitor::All(T::kPadding, valid_padding_predicate);
       if (!padding_valid) {
         decoder->SetError(kCodingErrorInvalidPaddingBytes);
       }
     }
   }

   static bool Equal(const T* struct1, const T* struct2) {
     bool equal = true;
     MemberVisitor<T>::Visit2(
         struct1, struct2, [&](const auto* member1, const auto* member2, auto& member_info) -> bool {
           if (*member1 != *member2) {
             equal = false;
             return false;
           }
           return true;
         });
     return equal;
   }
 };

 template <typename T>
 struct NaturalEmptyStructCodingTraits {
   static constexpr size_t inline_size_v2 = 1;
   static constexpr bool is_memcpy_compatible = false;

   static void Encode(NaturalEncoder* encoder, T* value, size_t offset, size_t recursion_depth) {}

   static void Decode(NaturalDecoder* decoder, T* value, size_t offset, size_t recursion_depth) {
     if (*decoder->GetPtr<uint8_t>(offset) != 0) {
       decoder->SetError(kCodingErrorInvalidPaddingBytes);
     }
   }
 };

 // This holds metadata about a table member: its ordinal, a member pointer to the member's value in
 // the table's Storage_ type, and optionally handle information.
 template <typename T, typename Field, typename Constraint_>
 struct NaturalTableMember final {
   using Constraint = Constraint_;
   size_t ordinal;
   std::optional<Field> T::*member_ptr;
   constexpr NaturalTableMember(size_t ordinal, std::optional<Field> T::*member_ptr) noexcept
       : ordinal(ordinal), member_ptr(member_ptr) {}
 };

 template <typename T>
 struct NaturalTableCodingTraits {
   static constexpr size_t inline_size_v2 = 16;
   static constexpr bool is_memcpy_compatible = false;

   template <class EncoderImpl>
   static void Encode(EncoderImpl* encoder, T* value, size_t offset, size_t recursion_depth) {
     size_t max_ordinal = MaxOrdinal(value);
     fidl_vector_t* vector = encoder->template GetPtr<fidl_vector_t>(offset);
     vector->count = max_ordinal;
     vector->data = reinterpret_cast<void*>(FIDL_ALLOC_PRESENT);
     if (max_ordinal == 0)
       return;
     if (recursion_depth + 2 > kRecursionDepthMax) {
       encoder->SetError(kCodingErrorRecursionDepthExceeded);
       return;
     }

     size_t base = encoder->Alloc(max_ordinal * sizeof(fidl_envelope_v2_t));
     MemberVisitor<T>::Visit(value, [&](auto* member, auto& member_info) {
       size_t offset = base + (member_info.ordinal - 1) * sizeof(fidl_envelope_v2_t);
       using Constraint = typename std::remove_reference_t<decltype(member_info)>::Constraint;
       NaturalEnvelopeEncodeOptional<Constraint>(encoder, member, offset, recursion_depth + 2);
     });
   }

   // Returns the largest ordinal of a present table member.
   template <size_t I = std::tuple_size_v<decltype(T::kMembers)> - 1>
   static size_t MaxOrdinal(T* value) {
     if constexpr (I == -1) {
       return 0;
     } else {
       auto T::Storage_::*member_ptr = std::get<I>(T::kMembers).member_ptr;
       const auto& member = value->storage_.*member_ptr;
       if (member.has_value()) {
         return std::get<I>(T::kMembers).ordinal;
       }
       return MaxOrdinal<I - 1>(value);
     }
   }

   static void Decode(NaturalDecoder* decoder, T* value, size_t offset, size_t recursion_depth) {
     fidl_vector_t* encoded = decoder->template GetPtr<fidl_vector_t>(offset);

     switch (reinterpret_cast<uintptr_t>(encoded->data)) {
       case FIDL_ALLOC_PRESENT:
         break;
       case FIDL_ALLOC_ABSENT: {
         decoder->SetError(kCodingErrorNullDataReceivedForTable);
         return;
       }
       default: {
         decoder->SetError(kCodingErrorInvalidPresenceIndicator);
         return;
       }
     }
     if (recursion_depth + 2 > kRecursionDepthMax) {
       decoder->SetError(kCodingErrorRecursionDepthExceeded);
       return;
     }

     size_t count = encoded->count;
     size_t base;
     if (!decoder->Alloc(sizeof(fidl_envelope_v2_t) * count, &base)) {
       return;
     }

     MemberVisitor<T>::Visit(value, [&](auto* member, auto& member_info) {
       size_t member_offset = base + (member_info.ordinal - 1) * sizeof(fidl_envelope_v2_t);
       if (member_info.ordinal <= count) {
         using Constraint = typename std::remove_reference_t<decltype(member_info)>::Constraint;
         NaturalEnvelopeDecodeOptional<Constraint>(decoder, member, member_offset, recursion_depth);
       } else {
         member->reset();
       }
     });
   }

   static bool Equal(const T* table1, const T* table2) {
     bool equal = true;
     MemberVisitor<T>::Visit2(table1, table2,
                              [&](const auto* member1, const auto* member2, auto& member_info) {
                                if (*member1 != *member2) {
                                  equal = false;
                                }
                              });
     return equal;
   }
 };

 // This holds metadata about a union member: a member pointer to the member's value in
 // the unions's Storage_ type, offsets, and optionally handle information.
 template <typename Constraint_>
 struct NaturalUnionMember final {
   using Constraint = Constraint_;
 };

 template <typename T>
 struct NaturalUnionCodingTraits {
   static constexpr size_t inline_size_v2 = 16;
   static constexpr bool is_memcpy_compatible = false;

   static void Encode(NaturalEncoder* encoder, T* value, size_t offset, size_t recursion_depth) {
     const size_t index = value->storage_->index();
     ZX_ASSERT(index > 0);
     if (recursion_depth + 1 > kRecursionDepthMax) {
       encoder->SetError(kCodingErrorRecursionDepthExceeded);
       return;
     }
     const size_t envelope_offset = offset + offsetof(fidl_xunion_t, envelope);
     EncodeMember(encoder, value, envelope_offset, index, recursion_depth + 1);
     // Call GetPtr after Encode because the buffer may move.
     fidl_xunion_v2_t* xunion = encoder->GetPtr<fidl_xunion_v2_t>(offset);
     xunion->tag = static_cast<fidl_union_tag_t>(T::IndexToTag(index).value());
   }

   template <size_t I = 1>
   static void EncodeMember(NaturalEncoder* encoder, T* value, size_t envelope_offset,
                            const size_t index, size_t recursion_depth) {
     static_assert(I > 0);
     if constexpr (I < std::variant_size_v<typename T::Storage_>) {
       if (I == index) {
         auto& member_info = std::get<I>(T::kMembers);
         using Constraint = typename std::remove_reference_t<decltype(member_info)>::Constraint;
         NaturalEnvelopeEncode<Constraint>(encoder, &std::get<I>(*value->storage_), envelope_offset,
                                           recursion_depth);
         return;
       }
       return EncodeMember<I + 1>(encoder, value, envelope_offset, index, recursion_depth);
     }
   }

   static void Decode(NaturalDecoder* decoder, T* value, size_t offset, size_t recursion_depth) {
     // Note: fidl_xunion_t and fidl_xunion_v2_t have xunion->tag in the same layout position
     // and the same value of offsetof(fidl_xunion_t, envelope).
     static_assert(sizeof(fidl_xunion_t::tag) == sizeof(fidl_xunion_v2_t::tag));
     static_assert(offsetof(fidl_xunion_t, tag) == offsetof(fidl_xunion_v2_t, tag));
     static_assert(offsetof(fidl_xunion_t, envelope) == offsetof(fidl_xunion_v2_t, envelope));

     fidl_xunion_v2_t* xunion = decoder->GetPtr<fidl_xunion_v2_t>(offset);
     const size_t index = T::TagToIndex(decoder, static_cast<typename T::Tag>(xunion->tag));
     if (decoder->status() != ZX_OK) {
       return;
     }
     ZX_ASSERT(index > 0);
     if (recursion_depth + 1 > kRecursionDepthMax) {
       decoder->SetError(kCodingErrorRecursionDepthExceeded);
       return;
     }
     const size_t envelope_offset = offset + offsetof(fidl_xunion_v2_t, envelope);
     DecodeMember(decoder, value, envelope_offset, index, recursion_depth + 1);
   }

   template <size_t I = 1>
   static void DecodeMember(NaturalDecoder* decoder, T* value, size_t envelope_offset,
                            const size_t index, size_t recursion_depth) {
     static_assert(I > 0);
     if constexpr (I < std::variant_size_v<typename T::Storage_>) {
       if (I == index) {
         using FieldType = cpp20::remove_cvref_t<decltype(std::get<I>(*value->storage_))>;
         value->storage_->template emplace<I>(
             DefaultConstructPossiblyInvalidObject<FieldType>::Make());
         auto& member_info = std::get<I>(T::kMembers);
         using Constraint = typename std::remove_reference_t<decltype(member_info)>::Constraint;
         NaturalEnvelopeDecode<Constraint>(decoder, &std::get<I>(*value->storage_), envelope_offset,
                                           recursion_depth);
         return;
       }
       return DecodeMember<I + 1>(decoder, value, envelope_offset, index, recursion_depth);
     }
     // TODO: dcheck
   }
 };

 // Helpers for deep-copying some types that aren't copy-constructible.
 // In particular ones that use std::unique_ptr, a common pattern in natural domain objects.
 template <typename T>
 struct NaturalCloneHelper {
   static T Clone(const T& value) { return value; }
 };

 template <typename T>
 struct NaturalCloneHelper<std::optional<T>> {
   static std::optional<T> Clone(const std::optional<T>& value) {
     if (value) {
       return std::make_optional<T>(NaturalCloneHelper<T>::Clone(value.value()));
     }
     return std::nullopt;
   }
 };

 template <typename T>
 struct NaturalCloneHelper<std::unique_ptr<T>> {
   static std::unique_ptr<T> Clone(const std::unique_ptr<T>& value) {
     return std::make_unique<T>(*value.get());
   }
 };

 template <typename T>
 struct NaturalCloneHelper<std::vector<T>> {
   static std::vector<T> Clone(const std::vector<T>& value) {
     std::vector<T> clone{};
     clone.reserve(value.size());
     std::transform(value.begin(), value.end(), std::back_inserter(clone),
                    [](const T& v) { return NaturalCloneHelper<T>::Clone(v); });
     return clone;
   }
 };

 template <typename T, size_t N, std::size_t... Indexes>
 std::array<T, N> ArrayCloneHelper(const std::array<T, N>& value, std::index_sequence<Indexes...>) {
   return std::array<T, N>{NaturalCloneHelper<T>::Clone(std::get<Indexes>(value))...};
 }

 template <typename T, size_t N>
 struct NaturalCloneHelper<std::array<T, N>> {
   static std::array<T, N> Clone(const std::array<T, N>& value) {
     return ArrayCloneHelper(value, std::make_index_sequence<N>());
   }
 };

 template <typename T>
 T NaturalClone(const T& value) {
   return NaturalCloneHelper<T>::Clone(value);
 }

 }  // namespace internal

 }  // namespace fidl

 #endif  // SRC_LIB_FIDL_CPP_INCLUDE_LIB_FIDL_CPP_INTERNAL_NATURAL_TYPES_H_
	// Copyright 2021 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#ifndef SRC_LIB_FIDL_CPP_INCLUDE_LIB_FIDL_CPP_INTERNAL_NATURAL_TYPES_H_
	#define SRC_LIB_FIDL_CPP_INCLUDE_LIB_FIDL_CPP_INTERNAL_NATURAL_TYPES_H_

	#include <lib/fidl/cpp/natural_coding_traits.h>
	#include <lib/fidl/cpp/natural_encoder.h>
	#include <lib/fidl/llcpp/message.h>
	#include <lib/fidl/llcpp/wire_types.h>
	#include <lib/fitx/result.h>
	#include <lib/stdcompat/type_traits.h>
	#include <zircon/fidl.h>

	#include <algorithm>
	#include <cstdint>
	#include <utility>
	#include <variant>

	// # Natural domain objects
	//
	// This header contains forward definitions that are part of natural domain
	// objects. The code generator should populate the implementation by generating
	// template specializations for each FIDL data type.
	namespace fidl {

	// \|Error\| is a type alias for when the result of an operation is an error.
	using Error = Status;

	namespace internal {

	class NaturalEncoder;

	template <typename Constraint, typename Field>
	void NaturalEnvelopeEncode(NaturalEncoder* encoder, Field* value, size_t offset,
	size_t recursion_depth) {
	if (value == nullptr) {
	// Nothing to encode.
	return;
	}

	const size_t length_before = encoder->CurrentLength();
	const size_t handles_before = encoder->CurrentHandleCount();

	if (::fidl::internal::NaturalEncodingInlineSize<Field, Constraint>(encoder) <=
	FIDL_ENVELOPE_INLINING_SIZE_THRESHOLD) {
	fidl::internal::NaturalEncode<Constraint>(encoder, value, offset, recursion_depth);

	// Call GetPtr after Encode because the buffer may move.
	fidl_envelope_v2_t* envelope = encoder->GetPtr<fidl_envelope_v2_t>(offset);
	envelope->num_handles = static_cast<uint16_t>(encoder->CurrentHandleCount() - handles_before);
	envelope->flags = FIDL_ENVELOPE_FLAGS_INLINING_MASK;
	return;
	}

	fidl::internal::NaturalEncode<Constraint>(
	encoder, value,
	encoder->Alloc(::fidl::internal::NaturalEncodingInlineSize<Field, Constraint>(encoder)),
	recursion_depth);

	// Call GetPtr after Encode because the buffer may move.
	fidl_envelope_v2_t* envelope = encoder->GetPtr<fidl_envelope_v2_t>(offset);
	envelope->num_bytes = static_cast<uint32_t>(encoder->CurrentLength() - length_before);
	envelope->num_handles = static_cast<uint16_t>(encoder->CurrentHandleCount() - handles_before);
	envelope->flags = 0;
	}

	template <typename Constraint, typename Field>
	void NaturalEnvelopeEncodeOptional(NaturalEncoder* encoder, std::optional<Field>* value,
	size_t offset, size_t recursion_depth) {
	if (!value->has_value()) {
	// Nothing to encode.
	return;
	}
	NaturalEnvelopeEncode<Constraint>(encoder, &value->value(), offset, recursion_depth);
	}

	template <typename Constraint, typename Field>
	void NaturalEnvelopeDecode(NaturalDecoder* decoder, Field* value, size_t offset,
	size_t recursion_depth) {
	size_t body_size = NaturalDecodingInlineSize<Field, Constraint>(decoder);
	const size_t length_before = decoder->CurrentLength();
	const size_t handles_before = decoder->CurrentHandleCount();

	fidl_envelope_v2_t* envelope = decoder->GetPtr<fidl_envelope_v2_t>(offset);
	if (::fidl::internal::NaturalDecodingInlineSize<Field, Constraint>(decoder) <=
	FIDL_ENVELOPE_INLINING_SIZE_THRESHOLD) {
	if (envelope->flags != FIDL_ENVELOPE_FLAGS_INLINING_MASK) {
	decoder->SetError(kCodingErrorInvalidInlineBit);
	return;
	}

	fidl::internal::NaturalDecode<Constraint>(
	decoder, value, decoder->GetOffset(&envelope->inline_value), recursion_depth);

	if (decoder->CurrentHandleCount() != handles_before + envelope->num_handles) {
	decoder->SetError(kCodingErrorInvalidNumHandlesSpecifiedInEnvelope);
	}

	uint32_t padding;
	switch (::fidl::internal::NaturalDecodingInlineSize<Field, Constraint>(decoder)) {
	case 1:
	padding = 0xffffff00;
	break;
	case 2:
	padding = 0xffff0000;
	break;
	case 3:
	padding = 0xff000000;
	break;
	case 4:
	padding = 0x00000000;
	break;
	default:
	__builtin_unreachable();
	}
	if ((*decoder->GetPtr<uint32_t>(offset) & padding) != 0) {
	decoder->SetError(kCodingErrorInvalidPaddingBytes);
	}

	return;
	}

	if (envelope->flags != 0) {
	decoder->SetError(kCodingErrorInvalidInlineBit);
	return;
	}

	size_t body_offset;
	if (!decoder->Alloc(body_size, &body_offset)) {
	return;
	}
	fidl::internal::NaturalDecode<Constraint>(decoder, value, body_offset, recursion_depth);

	if (decoder->CurrentHandleCount() != handles_before + envelope->num_handles) {
	decoder->SetError(kCodingErrorInvalidNumHandlesSpecifiedInEnvelope);
	}
	if (decoder->CurrentLength() != length_before + envelope->num_bytes) {
	decoder->SetError(kCodingErrorInvalidNumBytesSpecifiedInEnvelope);
	}
	}

	template <typename Constraint, typename Field>
	void NaturalEnvelopeDecodeOptional(NaturalDecoder* decoder, std::optional<Field>* value,
	size_t offset, size_t recursion_depth) {
	fidl_envelope_v2_t* envelope = decoder->GetPtr<fidl_envelope_v2_t>(offset);
	if (reinterpret_cast<const void const*>(envelope) == nullptr) {
	value->reset();
	return;
	}
	value->emplace(DefaultConstructPossiblyInvalidObject<Field>::Make());
	NaturalEnvelopeDecode<Constraint>(decoder, &value->value(), offset, recursion_depth);
	}

	// MemberVisitor provides helpers to invoke visitor functions over natural struct and natural table
	// members. This works because structs and tables have similar shapes in the natural bindings.
	// There is an instance data member called `storage_` which is a struct containing the member data
	// and a constexpr std::tuple member called `kMembers`, and each member of that has a `member_ptr`
	// which is a member pointer into the `storage_` struct.
	template <typename T>
	struct MemberVisitor {
	static constexpr auto kMembers = T::kMembers;
	static constexpr size_t kNumMembers = std::tuple_size_v<decltype(kMembers)>;

	// Visit each of the members in order while the visitor function returns a truthy value.
	template <typename U, typename Fn, size_t I = 0>
	static void VisitWhile(U value, Fn func) {
	static_assert(std::is_same_v<T, U> \|\| std::is_same_v<const T, U>);
	if constexpr (I < kNumMembers) {
	auto& member_info = std::get<I>(kMembers);
	auto* member_ptr = &(value->storage_.*(member_info.member_ptr));

	if (func(member_ptr, member_info)) {
	VisitWhile<U, Fn, I + 1>(value, func);
	}
	}
	}

	// Visit all of the members in order.
	template <typename U, typename Fn>
	static void Visit(U value, Fn func) {
	static_assert(std::is_same_v<T, U> \|\| std::is_same_v<const T, U>);
	VisitWhile(value, [func = std::move(func)](auto member_ptr, auto member_info) {
	func(member_ptr, member_info);
	return true;
	});
	}

	// Visit each of the members of two structs or tables in order while the visitor function returns
	// a truthy value.
	template <typename U, typename Fn, size_t I = 0>
	static void Visit2While(U value1, U value2, Fn func) {
	static_assert(std::is_same_v<T, U> \|\| std::is_same_v<const T, U>);
	if constexpr (I < std::tuple_size_v<decltype(T::kMembers)>) {
	auto& member_info = std::get<I>(T::kMembers);
	auto* member_ptr1 = &(value1->storage_.*(member_info.member_ptr));
	auto* member_ptr2 = &(value2->storage_.*(member_info.member_ptr));

	if (func(member_ptr1, member_ptr2, member_info)) {
	Visit2While<U, Fn, I + 1>(value1, value2, func);
	}
	}
	}

	// Visit all of the members of two structs or tables in order.
	template <typename U, typename Fn>
	static void Visit2(U value1, U value2, Fn func) {
	static_assert(std::is_same_v<T, U> \|\| std::is_same_v<const T, U>);
	Visit2While(value1, value2,
	[func = std::move(func)](auto member1, auto member2, auto member_info) {
	func(member1, member2, member_info);
	return true;
	});
	}
	};

	// This holds metadata about a struct member: a member pointer to the member's value in
	// the struct's Storage_ type, offsets, and optionally handle information.
	template <typename T, typename Field_, typename Constraint_>
	struct NaturalStructMember final {
	using Field = Field_;
	using Constraint = Constraint_;
	Field T::*member_ptr;
	size_t offset;
	explicit constexpr NaturalStructMember(Field T::*member_ptr, size_t offset) noexcept
	: member_ptr(member_ptr), offset(offset) {}
	};

	struct TupleVisitor {
	public:
	// Returns true iff the \|func\| is satified on all items of \|tuple\|.
	//
	// e.g. TupleVisitor::All(std::make_tuple(1, 2, 3), [](int v) { return v > 0; })
	// returns true because 1, 2, 3 are all > 0.
	template <typename Tuple, typename Fn, size_t I = 0>
	static constexpr auto All(Tuple tuple, Fn func) {
	if constexpr (I == std::tuple_size_v<Tuple>) {
	return true;
	} else {
	return func(std::get<I>(tuple)) && All<Tuple, Fn, I + 1>(tuple, func);
	}
	}
	};

	template <typename MaskType>
	struct NaturalStructPadding final {
	// Offset within the struct (start of struct = 0).
	size_t offset;
	MaskType mask;

	[[nodiscard]] bool ValidatePadding(NaturalDecoder* decoder, size_t base_offset) {
	return (*decoder->GetPtr<MaskType>(base_offset + offset) & mask) == 0;
	}
	};

	template <typename T, size_t Size>
	struct NaturalStructCodingTraits {
	static constexpr size_t inline_size_v2 = Size;
	// True iff all fields are memcpy compatible.
	static constexpr bool are_members_memcpy_compatible =
	TupleVisitor::All(T::kMembers, [](auto member_info) {
	using Field = typename std::remove_reference_t<decltype(member_info)>::Field;
	using Constraint = typename std::remove_reference_t<decltype(member_info)>::Constraint;
	return NaturalIsMemcpyCompatible<Field, Constraint>();
	});
	// True iff fields are memcpy compatible and there is no padding.
	static constexpr bool is_memcpy_compatible =
	are_members_memcpy_compatible && std::tuple_size_v<decltype(T::kPadding)> == 0;

	static void Encode(NaturalEncoder* encoder, T* value, size_t offset, size_t recursion_depth) {
	if constexpr (is_memcpy_compatible) {
	memcpy(encoder->GetPtr<T>(offset), value, sizeof(T));
	} else {
	MemberVisitor<T>::Visit(value, [&](auto* member, auto& member_info) -> void {
	using Constraint = typename std::remove_reference_t<decltype(member_info)>::Constraint;
	fidl::internal::NaturalEncode<Constraint>(encoder, member, offset + member_info.offset,
	recursion_depth);
	});
	}
	}

	static void Decode(NaturalDecoder* decoder, T* value, size_t offset, size_t recursion_depth) {
	if constexpr (is_memcpy_compatible) {
	memcpy(value, decoder->GetPtr<T>(offset), sizeof(T));
	} else {
	MemberVisitor<T>::Visit(value, [&](auto* member, auto& member_info) {
	using Constraint = typename std::remove_reference_t<decltype(member_info)>::Constraint;
	fidl::internal::NaturalDecode<Constraint>(decoder, member, offset + member_info.offset,
	recursion_depth);
	});

	auto valid_padding_predicate = [decoder, offset](auto padding) {
	return padding.ValidatePadding(decoder, offset);
	};
	bool padding_valid = TupleVisitor::All(T::kPadding, valid_padding_predicate);
	if (!padding_valid) {
	decoder->SetError(kCodingErrorInvalidPaddingBytes);
	}
	}
	}

	static bool Equal(const T* struct1, const T* struct2) {
	bool equal = true;
	MemberVisitor<T>::Visit2(
	struct1, struct2, [&](const auto* member1, const auto* member2, auto& member_info) -> bool {
	if (member1 != member2) {
	equal = false;
	return false;
	}
	return true;
	});
	return equal;
	}
	};

	template <typename T>
	struct NaturalEmptyStructCodingTraits {
	static constexpr size_t inline_size_v2 = 1;
	static constexpr bool is_memcpy_compatible = false;

	static void Encode(NaturalEncoder* encoder, T* value, size_t offset, size_t recursion_depth) {}

	static void Decode(NaturalDecoder* decoder, T* value, size_t offset, size_t recursion_depth) {
	if (*decoder->GetPtr<uint8_t>(offset) != 0) {
	decoder->SetError(kCodingErrorInvalidPaddingBytes);
	}
	}
	};

	// This holds metadata about a table member: its ordinal, a member pointer to the member's value in
	// the table's Storage_ type, and optionally handle information.
	template <typename T, typename Field, typename Constraint_>
	struct NaturalTableMember final {
	using Constraint = Constraint_;
	size_t ordinal;
	std::optional<Field> T::*member_ptr;
	constexpr NaturalTableMember(size_t ordinal, std::optional<Field> T::*member_ptr) noexcept
	: ordinal(ordinal), member_ptr(member_ptr) {}
	};

	template <typename T>
	struct NaturalTableCodingTraits {
	static constexpr size_t inline_size_v2 = 16;
	static constexpr bool is_memcpy_compatible = false;

	template <class EncoderImpl>
	static void Encode(EncoderImpl* encoder, T* value, size_t offset, size_t recursion_depth) {
	size_t max_ordinal = MaxOrdinal(value);
	fidl_vector_t* vector = encoder->template GetPtr<fidl_vector_t>(offset);
	vector->count = max_ordinal;
	vector->data = reinterpret_cast<void*>(FIDL_ALLOC_PRESENT);
	if (max_ordinal == 0)
	return;
	if (recursion_depth + 2 > kRecursionDepthMax) {
	encoder->SetError(kCodingErrorRecursionDepthExceeded);
	return;
	}

	size_t base = encoder->Alloc(max_ordinal * sizeof(fidl_envelope_v2_t));
	MemberVisitor<T>::Visit(value, [&](auto* member, auto& member_info) {
	size_t offset = base + (member_info.ordinal - 1) * sizeof(fidl_envelope_v2_t);
	using Constraint = typename std::remove_reference_t<decltype(member_info)>::Constraint;
	NaturalEnvelopeEncodeOptional<Constraint>(encoder, member, offset, recursion_depth + 2);
	});
	}

	// Returns the largest ordinal of a present table member.
	template <size_t I = std::tuple_size_v<decltype(T::kMembers)> - 1>
	static size_t MaxOrdinal(T* value) {
	if constexpr (I == -1) {
	return 0;
	} else {
	auto T::Storage_::*member_ptr = std::get<I>(T::kMembers).member_ptr;
	const auto& member = value->storage_.*member_ptr;
	if (member.has_value()) {
	return std::get<I>(T::kMembers).ordinal;
	}
	return MaxOrdinal<I - 1>(value);
	}
	}

	static void Decode(NaturalDecoder* decoder, T* value, size_t offset, size_t recursion_depth) {
	fidl_vector_t* encoded = decoder->template GetPtr<fidl_vector_t>(offset);

	switch (reinterpret_cast<uintptr_t>(encoded->data)) {
	case FIDL_ALLOC_PRESENT:
	break;
	case FIDL_ALLOC_ABSENT: {
	decoder->SetError(kCodingErrorNullDataReceivedForTable);
	return;
	}
	default: {
	decoder->SetError(kCodingErrorInvalidPresenceIndicator);
	return;
	}
	}
	if (recursion_depth + 2 > kRecursionDepthMax) {
	decoder->SetError(kCodingErrorRecursionDepthExceeded);
	return;
	}

	size_t count = encoded->count;
	size_t base;
	if (!decoder->Alloc(sizeof(fidl_envelope_v2_t) * count, &base)) {
	return;
	}

	MemberVisitor<T>::Visit(value, [&](auto* member, auto& member_info) {
	size_t member_offset = base + (member_info.ordinal - 1) * sizeof(fidl_envelope_v2_t);
	if (member_info.ordinal <= count) {
	using Constraint = typename std::remove_reference_t<decltype(member_info)>::Constraint;
	NaturalEnvelopeDecodeOptional<Constraint>(decoder, member, member_offset, recursion_depth);
	} else {
	member->reset();
	}
	});
	}

	static bool Equal(const T* table1, const T* table2) {
	bool equal = true;
	MemberVisitor<T>::Visit2(table1, table2,
	[&](const auto* member1, const auto* member2, auto& member_info) {
	if (member1 != member2) {
	equal = false;
	}
	});
	return equal;
	}
	};

	// This holds metadata about a union member: a member pointer to the member's value in
	// the unions's Storage_ type, offsets, and optionally handle information.
	template <typename Constraint_>
	struct NaturalUnionMember final {
	using Constraint = Constraint_;
	};

	template <typename T>
	struct NaturalUnionCodingTraits {
	static constexpr size_t inline_size_v2 = 16;
	static constexpr bool is_memcpy_compatible = false;

	static void Encode(NaturalEncoder* encoder, T* value, size_t offset, size_t recursion_depth) {
	const size_t index = value->storage_->index();
	ZX_ASSERT(index > 0);
	if (recursion_depth + 1 > kRecursionDepthMax) {
	encoder->SetError(kCodingErrorRecursionDepthExceeded);
	return;
	}
	const size_t envelope_offset = offset + offsetof(fidl_xunion_t, envelope);
	EncodeMember(encoder, value, envelope_offset, index, recursion_depth + 1);
	// Call GetPtr after Encode because the buffer may move.
	fidl_xunion_v2_t* xunion = encoder->GetPtr<fidl_xunion_v2_t>(offset);
	xunion->tag = static_cast<fidl_union_tag_t>(T::IndexToTag(index).value());
	}

	template <size_t I = 1>
	static void EncodeMember(NaturalEncoder* encoder, T* value, size_t envelope_offset,
	const size_t index, size_t recursion_depth) {
	static_assert(I > 0);
	if constexpr (I < std::variant_size_v<typename T::Storage_>) {
	if (I == index) {
	auto& member_info = std::get<I>(T::kMembers);
	using Constraint = typename std::remove_reference_t<decltype(member_info)>::Constraint;
	NaturalEnvelopeEncode<Constraint>(encoder, &std::get<I>(*value->storage_), envelope_offset,
	recursion_depth);
	return;
	}
	return EncodeMember<I + 1>(encoder, value, envelope_offset, index, recursion_depth);
	}
	}

	static void Decode(NaturalDecoder* decoder, T* value, size_t offset, size_t recursion_depth) {
	// Note: fidl_xunion_t and fidl_xunion_v2_t have xunion->tag in the same layout position
	// and the same value of offsetof(fidl_xunion_t, envelope).
	static_assert(sizeof(fidl_xunion_t::tag) == sizeof(fidl_xunion_v2_t::tag));
	static_assert(offsetof(fidl_xunion_t, tag) == offsetof(fidl_xunion_v2_t, tag));
	static_assert(offsetof(fidl_xunion_t, envelope) == offsetof(fidl_xunion_v2_t, envelope));

	fidl_xunion_v2_t* xunion = decoder->GetPtr<fidl_xunion_v2_t>(offset);
	const size_t index = T::TagToIndex(decoder, static_cast<typename T::Tag>(xunion->tag));
	if (decoder->status() != ZX_OK) {
	return;
	}
	ZX_ASSERT(index > 0);
	if (recursion_depth + 1 > kRecursionDepthMax) {
	decoder->SetError(kCodingErrorRecursionDepthExceeded);
	return;
	}
	const size_t envelope_offset = offset + offsetof(fidl_xunion_v2_t, envelope);
	DecodeMember(decoder, value, envelope_offset, index, recursion_depth + 1);
	}

	template <size_t I = 1>
	static void DecodeMember(NaturalDecoder* decoder, T* value, size_t envelope_offset,
	const size_t index, size_t recursion_depth) {
	static_assert(I > 0);
	if constexpr (I < std::variant_size_v<typename T::Storage_>) {
	if (I == index) {
	using FieldType = cpp20::remove_cvref_t<decltype(std::get<I>(*value->storage_))>;
	value->storage_->template emplace<I>(
	DefaultConstructPossiblyInvalidObject<FieldType>::Make());
	auto& member_info = std::get<I>(T::kMembers);
	using Constraint = typename std::remove_reference_t<decltype(member_info)>::Constraint;
	NaturalEnvelopeDecode<Constraint>(decoder, &std::get<I>(*value->storage_), envelope_offset,
	recursion_depth);
	return;
	}
	return DecodeMember<I + 1>(decoder, value, envelope_offset, index, recursion_depth);
	}
	// TODO: dcheck
	}
	};

	// Helpers for deep-copying some types that aren't copy-constructible.
	// In particular ones that use std::unique_ptr, a common pattern in natural domain objects.
	template <typename T>
	struct NaturalCloneHelper {
	static T Clone(const T& value) { return value; }
	};

	template <typename T>
	struct NaturalCloneHelper<std::optional<T>> {
	static std::optional<T> Clone(const std::optional<T>& value) {
	if (value) {
	return std::make_optional<T>(NaturalCloneHelper<T>::Clone(value.value()));
	}
	return std::nullopt;
	}
	};

	template <typename T>
	struct NaturalCloneHelper<std::unique_ptr<T>> {
	static std::unique_ptr<T> Clone(const std::unique_ptr<T>& value) {
	return std::make_unique<T>(*value.get());
	}
	};

	template <typename T>
	struct NaturalCloneHelper<std::vector<T>> {
	static std::vector<T> Clone(const std::vector<T>& value) {
	std::vector<T> clone{};
	clone.reserve(value.size());
	std::transform(value.begin(), value.end(), std::back_inserter(clone),
	[](const T& v) { return NaturalCloneHelper<T>::Clone(v); });
	return clone;
	}
	};

	template <typename T, size_t N, std::size_t... Indexes>
	std::array<T, N> ArrayCloneHelper(const std::array<T, N>& value, std::index_sequence<Indexes...>) {
	return std::array<T, N>{NaturalCloneHelper<T>::Clone(std::get<Indexes>(value))...};
	}

	template <typename T, size_t N>
	struct NaturalCloneHelper<std::array<T, N>> {
	static std::array<T, N> Clone(const std::array<T, N>& value) {
	return ArrayCloneHelper(value, std::make_index_sequence<N>());
	}
	};

	template <typename T>
	T NaturalClone(const T& value) {
	return NaturalCloneHelper<T>::Clone(value);
	}

	} // namespace internal

	} // namespace fidl

	#endif // SRC_LIB_FIDL_CPP_INCLUDE_LIB_FIDL_CPP_INTERNAL_NATURAL_TYPES_H_