// WARNING: This file is machine generated by fidlgen.

#pragma once

#include <exampleusing/cpp/libfuzzer.h>
#include <fidl/test/placementofattributes/cpp/fidl.h>

#include "lib/fidl/cpp/fuzzing/traits.h"
#include "lib/fidl/cpp/internal/header.h"
// For ::std::max_element().
#include <algorithm>
// For uint64_t.
#include <stdint.h>

namespace fuzzing {

using ExampleXUnion = ::fidl::test::placementofattributes::ExampleXUnion;
using ExampleUnion = ::fidl::test::placementofattributes::ExampleUnion;
using ExampleTable = ::fidl::test::placementofattributes::ExampleTable;
using ExampleStruct = ::fidl::test::placementofattributes::ExampleStruct;
using ExampleEnum = ::fidl::test::placementofattributes::ExampleEnum;
using ExampleBits = ::fidl::test::placementofattributes::ExampleBits;

template <>
struct MinSize<ExampleXUnion> {
  operator size_t() {
    size_t sizes[] = {0, MinSize<uint32_t>()};
    return 1 + *std::max_element(sizes, sizes + 1 + 1);
  }
};
template <>
struct Allocate<ExampleXUnion> {
  static_assert(1 > 0, "xunion must have at least one member");

  ExampleXUnion operator()(FuzzInput* src, size_t* size) {
    ZX_ASSERT(*size >= MinSize<ExampleXUnion>());

    uint8_t selector;
    ZX_ASSERT(src->CopyBytes(&selector, 1));
    (*size)++;

    ExampleXUnion out;
    switch (selector % 1) {
      case 0: {
        out.set_variant(Allocate<uint32_t>{}(src, size));
        break;
      }
    }

    return out;
  }
};
template <>
struct MinSize<ExampleUnion> {
  operator size_t() {
    size_t sizes[] = {0, MinSize<uint32_t>()};
    return 1 + *std::max_element(sizes, sizes + 1 + 1);
  }
};
template <>
struct Allocate<ExampleUnion> {
  static_assert(1 > 0, "xunion must have at least one member");

  ExampleUnion operator()(FuzzInput* src, size_t* size) {
    ZX_ASSERT(*size >= MinSize<ExampleUnion>());

    uint8_t selector;
    ZX_ASSERT(src->CopyBytes(&selector, 1));
    (*size)++;

    ExampleUnion out;
    switch (selector % 1) {
      case 0: {
        out.set_variant(Allocate<uint32_t>{}(src, size));
        break;
      }
    }

    return out;
  }
};
template <>
struct MinSize<ExampleTable> {
  operator size_t() { return MinSize<uint32_t>(); }
};
template <>
struct Allocate<ExampleTable> {
  ExampleTable operator()(FuzzInput* src, size_t* size) {
    ZX_ASSERT(*size >= MinSize<ExampleTable>());
    ExampleTable out;
    const size_t slack_per_member = (*size - MinSize<ExampleTable>()) / 1;
    size_t out_size;
    out_size = MinSize<uint32_t>() + slack_per_member;
    out.set_member(Allocate<uint32_t>{}(src, &out_size));
    return out;
  }
};
template <>
struct MinSize<ExampleStruct> {
  operator size_t() { return MinSize<uint32_t>(); }
};
template <>
struct Allocate<ExampleStruct> {
  ExampleStruct operator()(FuzzInput* src, size_t* size) {
    ZX_ASSERT(*size >= MinSize<ExampleStruct>());
    ExampleStruct out;
    const size_t slack_per_member = (*size - MinSize<ExampleStruct>()) / 1;
    size_t out_size;
    out_size = MinSize<uint32_t>() + slack_per_member;
    out.member = Allocate<uint32_t>{}(src, &out_size);
    return out;
  }
};
template <>
struct MinSize<ExampleEnum> {
  operator size_t() { return sizeof(uint64_t); }
};
template <>
struct Allocate<ExampleEnum> {
  ExampleEnum operator()(FuzzInput* src, size_t* size) {
    ExampleEnum out;
    uint64_t selector;
    ZX_ASSERT(*size >= sizeof(uint64_t));
    ZX_ASSERT(src->CopyObject(&selector));
    *size = sizeof(uint64_t);

    switch (selector % 1) {
      case 0:
        out = ExampleEnum::MEMBER;
        break;
    }

    return out;
  }
};
template <>
struct MinSize<ExampleBits> {
  operator size_t() { return sizeof(ExampleBits); }
};
template <>
struct Allocate<ExampleBits> {
  ExampleBits operator()(FuzzInput* src, size_t* size) {
    ExampleBits out;
    ZX_ASSERT(*size >= sizeof(ExampleBits));
    ZX_ASSERT(src->CopyObject(&out));
    *size = sizeof(ExampleBits);
    return out;
  }
};

}  // namespace fuzzing