// services/network/public/mojom/no_vary_search.mojom-blink.cc is auto generated by mojom_bindings_generator.py, do not edit

// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-private-field"
#endif

#include "services/network/public/mojom/no_vary_search.mojom-blink.h"
#include <stdint.h>
#include <utility>
#include "base/notreached.h"
#include "mojo/public/cpp/bindings/lib/default_construct_tag_internal.h"
#include "mojo/public/cpp/bindings/lib/serialization.h"
#include "mojo/public/cpp/bindings/lib/validate_params.h"
#include "mojo/public/cpp/bindings/lib/validation_errors.h"
#include "mojo/public/cpp/bindings/mojo_buildflags.h"
#include "third_party/perfetto/include/perfetto/tracing/traced_value.h"

#include "services/network/public/mojom/no_vary_search.mojom-params-data.h"
#include "services/network/public/mojom/no_vary_search.mojom-shared-message-ids.h"

#include "services/network/public/mojom/no_vary_search.mojom-blink-import-headers.h"
#include "services/network/public/mojom/no_vary_search.mojom-blink-test-utils.h"
#include "mojo/public/cpp/bindings/lib/wtf_serialization.h"


namespace network::mojom::blink {
NoVarySearch::NoVarySearch()
    : search_variance(),
      vary_on_key_order() {}

NoVarySearch::NoVarySearch(
    SearchParamsVariancePtr search_variance_in,
    bool vary_on_key_order_in)
    : search_variance(std::move(search_variance_in)),
      vary_on_key_order(std::move(vary_on_key_order_in)) {}

NoVarySearch::~NoVarySearch() = default;

void NoVarySearch::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "search_variance"), this->search_variance,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type SearchParamsVariancePtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "vary_on_key_order"), this->vary_on_key_order,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool NoVarySearch::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
SearchParamsVariancePtr
SearchParamsVariance::NewNoVaryParams(
    ::blink::Vector<::blink::String> value) {
  return SearchParamsVariancePtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kNoVaryParams)>,
      std::move(value));
}

SearchParamsVariancePtr
SearchParamsVariance::NewVaryParams(
    ::blink::Vector<::blink::String> value) {
  return SearchParamsVariancePtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kVaryParams)>,
      std::move(value));
}

SearchParamsVariance::SearchParamsVariance(
    std::in_place_index_t<static_cast<size_t>(Tag::kNoVaryParams)>,
    ::blink::Vector<::blink::String> value)
    : tag_(Tag::kNoVaryParams),
      data_(std::in_place_index<static_cast<size_t>(Tag::kNoVaryParams)>,
            std::move(value)) {}

SearchParamsVariance::SearchParamsVariance(
    std::in_place_index_t<static_cast<size_t>(Tag::kVaryParams)>,
    ::blink::Vector<::blink::String> value)
    : tag_(Tag::kVaryParams),
      data_(std::in_place_index<static_cast<size_t>(Tag::kVaryParams)>,
            std::move(value)) {}
SearchParamsVariance::~SearchParamsVariance() {
  DestroyActive();
}

void SearchParamsVariance::set_no_vary_params(::blink::Vector<::blink::String> no_vary_params) {
  if (tag_ == Tag::kNoVaryParams) {
    data_.no_vary_params = std::move(no_vary_params);
  } else {
    DestroyActive();
    tag_ = Tag::kNoVaryParams;
    new (&data_.no_vary_params) ::blink::Vector<::blink::String>(
        std::move(no_vary_params));
  }
}

void SearchParamsVariance::set_vary_params(::blink::Vector<::blink::String> vary_params) {
  if (tag_ == Tag::kVaryParams) {
    data_.vary_params = std::move(vary_params);
  } else {
    DestroyActive();
    tag_ = Tag::kVaryParams;
    new (&data_.vary_params) ::blink::Vector<::blink::String>(
        std::move(vary_params));
  }
}


SearchParamsVariance::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kNoVaryParams)>,
    ::blink::Vector<::blink::String> value)
    : no_vary_params(std::move(value)) {}

SearchParamsVariance::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kVaryParams)>,
    ::blink::Vector<::blink::String> value)
    : vary_params(std::move(value)) {}

void SearchParamsVariance::DestroyActive() {
  switch (tag_) {

    case Tag::kNoVaryParams:
      std::destroy_at(&data_.no_vary_params);
      break;
    case Tag::kVaryParams:
      std::destroy_at(&data_.vary_params);
      break;
  }
}

bool SearchParamsVariance::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
NoVarySearchWithParseErrorPtr
NoVarySearchWithParseError::NewNoVarySearch(
    NoVarySearchPtr value) {
  return NoVarySearchWithParseErrorPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kNoVarySearch)>,
      std::move(value));
}

NoVarySearchWithParseErrorPtr
NoVarySearchWithParseError::NewParseError(
    NoVarySearchParseError value) {
  return NoVarySearchWithParseErrorPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kParseError)>,
      std::move(value));
}

NoVarySearchWithParseError::NoVarySearchWithParseError(
    std::in_place_index_t<static_cast<size_t>(Tag::kNoVarySearch)>,
    NoVarySearchPtr value)
    : tag_(Tag::kNoVarySearch),
      data_(std::in_place_index<static_cast<size_t>(Tag::kNoVarySearch)>,
            std::move(value)) {}

NoVarySearchWithParseError::NoVarySearchWithParseError(
    std::in_place_index_t<static_cast<size_t>(Tag::kParseError)>,
    NoVarySearchParseError value)
    : tag_(Tag::kParseError),
      data_(std::in_place_index<static_cast<size_t>(Tag::kParseError)>,
            std::move(value)) {}
NoVarySearchWithParseError::~NoVarySearchWithParseError() {
  DestroyActive();
}

void NoVarySearchWithParseError::set_no_vary_search(NoVarySearchPtr no_vary_search) {
  if (tag_ == Tag::kNoVarySearch) {
    data_.no_vary_search = std::move(no_vary_search);
  } else {
    DestroyActive();
    tag_ = Tag::kNoVarySearch;
    new (&data_.no_vary_search) NoVarySearchPtr(
        std::move(no_vary_search));
  }
}

void NoVarySearchWithParseError::set_parse_error(NoVarySearchParseError parse_error) {
  if (tag_ != Tag::kParseError) {
    DestroyActive();
    tag_ = Tag::kParseError;
  }
  data_.parse_error = parse_error;
}


NoVarySearchWithParseError::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kNoVarySearch)>,
    NoVarySearchPtr value)
    : no_vary_search(std::move(value)) {}

NoVarySearchWithParseError::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kParseError)>,
    NoVarySearchParseError value)
    : parse_error(std::move(value)) {}

void NoVarySearchWithParseError::DestroyActive() {
  switch (tag_) {

    case Tag::kNoVarySearch:
      std::destroy_at(&data_.no_vary_search);
      break;
    case Tag::kParseError:
      std::destroy_at(&data_.parse_error);
      break;
  }
}

bool NoVarySearchWithParseError::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}


}  // network::mojom::blink


namespace mojo {


// static
bool StructTraits<::network::mojom::blink::NoVarySearch::DataView, ::network::mojom::blink::NoVarySearchPtr>::Read(
    ::network::mojom::blink::NoVarySearch::DataView input,
    ::network::mojom::blink::NoVarySearchPtr* output) {
  bool success = true;
  ::network::mojom::blink::NoVarySearchPtr result(::network::mojom::blink::NoVarySearch::New());
  
      if (success && !input.ReadSearchVariance(&result->search_variance))
        success = false;
      if (success)
        result->vary_on_key_order = input.vary_on_key_order();
  *output = std::move(result);
  return success;
}

// static
bool UnionTraits<::network::mojom::blink::SearchParamsVariance::DataView, ::network::mojom::blink::SearchParamsVariancePtr>::Read(
    ::network::mojom::blink::SearchParamsVariance::DataView input,
    ::network::mojom::blink::SearchParamsVariancePtr* output) {
  using UnionType = ::network::mojom::blink::SearchParamsVariance;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kNoVaryParams: {
      ::blink::Vector<::blink::String> result_no_vary_params{};
      if (!input.ReadNoVaryParams(&result_no_vary_params))
        return false;

      *output = UnionType::NewNoVaryParams(
          std::move(result_no_vary_params));
      break;
    }
    case Tag::kVaryParams: {
      ::blink::Vector<::blink::String> result_vary_params{};
      if (!input.ReadVaryParams(&result_vary_params))
        return false;

      *output = UnionType::NewVaryParams(
          std::move(result_vary_params));
      break;
    }
    default:

      return false;
  }
  return true;
}

// static
bool UnionTraits<::network::mojom::blink::NoVarySearchWithParseError::DataView, ::network::mojom::blink::NoVarySearchWithParseErrorPtr>::Read(
    ::network::mojom::blink::NoVarySearchWithParseError::DataView input,
    ::network::mojom::blink::NoVarySearchWithParseErrorPtr* output) {
  using UnionType = ::network::mojom::blink::NoVarySearchWithParseError;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kNoVarySearch: {
      ::network::mojom::blink::NoVarySearchPtr result_no_vary_search{};
      if (!input.ReadNoVarySearch(&result_no_vary_search))
        return false;

      *output = UnionType::NewNoVarySearch(
          std::move(result_no_vary_search));
      break;
    }
    case Tag::kParseError: {
      ::network::mojom::blink::NoVarySearchParseError result_parse_error;
      if (!input.ReadParseError(&result_parse_error))
        return false;

      *output = UnionType::NewParseError(result_parse_error);
      break;
    }
    default:

      return false;
  }
  return true;
}

}  // namespace mojo


// Symbols declared in the -test-utils.h header are defined here instead of a
// separate .cc file to save compile time.


namespace network::mojom::blink {




}  // network::mojom::blink


#if defined(__clang__)
#pragma clang diagnostic pop
#endif