// components/optimization_guide/public/mojom/model_broker.mojom-shared.h is auto generated by mojom_bindings_generator.py, do not edit

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

#ifndef COMPONENTS_OPTIMIZATION_GUIDE_PUBLIC_MOJOM_MODEL_BROKER_MOJOM_SHARED_H_
#define COMPONENTS_OPTIMIZATION_GUIDE_PUBLIC_MOJOM_MODEL_BROKER_MOJOM_SHARED_H_

#include <stdint.h>

#include <functional>
#include <iosfwd>
#include <type_traits>
#include <utility>
#include "mojo/public/cpp/bindings/array_data_view.h"
#include "mojo/public/cpp/bindings/map_data_view.h"
#include "mojo/public/cpp/bindings/string_data_view.h"
#include "mojo/public/cpp/system/message_pipe.h"

#include "third_party/perfetto/include/perfetto/tracing/traced_value_forward.h"

#include "components/optimization_guide/public/mojom/model_broker.mojom-shared-internal.h"
#include "mojo/public/mojom/base/proto_wrapper.mojom-shared.h"
#include "services/on_device_model/public/mojom/download_observer.mojom-shared.h"
#include "services/on_device_model/public/mojom/on_device_model.mojom-shared.h"
#include "mojo/public/cpp/bindings/lib/interface_serialization.h"
#include "mojo/public/cpp/system/data_pipe.h"



#include "components/optimization_guide/public/mojom/model_broker.mojom-data-view.h"  // IWYU pragma: export




namespace std {

template <>
struct hash<::optimization_guide::mojom::OnDeviceFeature>
    : public mojo::internal::EnumHashImpl<::optimization_guide::mojom::OnDeviceFeature> {};

template <>
struct hash<::optimization_guide::mojom::ModelUnavailableReason>
    : public mojo::internal::EnumHashImpl<::optimization_guide::mojom::ModelUnavailableReason> {};

template <>
struct hash<::optimization_guide::mojom::ModelNotSupportedDetailedReason>
    : public mojo::internal::EnumHashImpl<::optimization_guide::mojom::ModelNotSupportedDetailedReason> {};

}  // namespace std

namespace mojo {


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::optimization_guide::mojom::OnDeviceFeature, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::optimization_guide::mojom::OnDeviceFeature, UserType>;

  static void Serialize(UserType input, int32_t* output) {
    *output = static_cast<int32_t>(Traits::ToMojom(input));
  }

  static bool Deserialize(int32_t input, UserType* output) {
    auto known_value = ::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::optimization_guide::mojom::OnDeviceFeature>(input));
    if constexpr (requires {
                    {
                      Traits::FromMojom(known_value)
                    } -> std::same_as<UserType>;
                  }) {
      static_assert(std::same_as<::optimization_guide::mojom::OnDeviceFeature, UserType> ||
                        HasInfallibleConversion(::optimization_guide::mojom::OnDeviceFeature()),
                    "::optimization_guide::mojom::OnDeviceFeature does not have an infallible conversion, "
                    "use an optional return type.");
      *output = Traits::FromMojom(known_value);
      return true;
    } else {
      static_assert(
          requires {
            {
              Traits::FromMojom(known_value)
            } -> std::same_as<std::optional<UserType>>;
          }, "FromMojom must return by value or optional.");
      std::optional<UserType> from_mojom = Traits::FromMojom(known_value);
      if (from_mojom) {
        *output = *from_mojom;
      }
      return from_mojom.has_value();
    }
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::optimization_guide::mojom::ModelUnavailableReason, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::optimization_guide::mojom::ModelUnavailableReason, UserType>;

  static void Serialize(UserType input, int32_t* output) {
    *output = static_cast<int32_t>(Traits::ToMojom(input));
  }

  static bool Deserialize(int32_t input, UserType* output) {
    auto known_value = ::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::optimization_guide::mojom::ModelUnavailableReason>(input));
    if constexpr (requires {
                    {
                      Traits::FromMojom(known_value)
                    } -> std::same_as<UserType>;
                  }) {
      static_assert(std::same_as<::optimization_guide::mojom::ModelUnavailableReason, UserType> ||
                        HasInfallibleConversion(::optimization_guide::mojom::ModelUnavailableReason()),
                    "::optimization_guide::mojom::ModelUnavailableReason does not have an infallible conversion, "
                    "use an optional return type.");
      *output = Traits::FromMojom(known_value);
      return true;
    } else {
      static_assert(
          requires {
            {
              Traits::FromMojom(known_value)
            } -> std::same_as<std::optional<UserType>>;
          }, "FromMojom must return by value or optional.");
      std::optional<UserType> from_mojom = Traits::FromMojom(known_value);
      if (from_mojom) {
        *output = *from_mojom;
      }
      return from_mojom.has_value();
    }
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::optimization_guide::mojom::ModelNotSupportedDetailedReason, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::optimization_guide::mojom::ModelNotSupportedDetailedReason, UserType>;

  static void Serialize(UserType input, int32_t* output) {
    *output = static_cast<int32_t>(Traits::ToMojom(input));
  }

  static bool Deserialize(int32_t input, UserType* output) {
    auto known_value = ::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::optimization_guide::mojom::ModelNotSupportedDetailedReason>(input));
    if constexpr (requires {
                    {
                      Traits::FromMojom(known_value)
                    } -> std::same_as<UserType>;
                  }) {
      static_assert(std::same_as<::optimization_guide::mojom::ModelNotSupportedDetailedReason, UserType> ||
                        HasInfallibleConversion(::optimization_guide::mojom::ModelNotSupportedDetailedReason()),
                    "::optimization_guide::mojom::ModelNotSupportedDetailedReason does not have an infallible conversion, "
                    "use an optional return type.");
      *output = Traits::FromMojom(known_value);
      return true;
    } else {
      static_assert(
          requires {
            {
              Traits::FromMojom(known_value)
            } -> std::same_as<std::optional<UserType>>;
          }, "FromMojom must return by value or optional.");
      std::optional<UserType> from_mojom = Traits::FromMojom(known_value);
      if (from_mojom) {
        *output = *from_mojom;
      }
      return from_mojom.has_value();
    }
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::optimization_guide::mojom::ModelSolutionConfigDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::optimization_guide::mojom::ModelSolutionConfigDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::optimization_guide::mojom::internal::ModelSolutionConfig_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::feature_config(input)) in_feature_config = Traits::feature_config(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->feature_config)::BaseType> feature_config_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::mojo_base::mojom::ProtoWrapperDataView>(
      in_feature_config,
      feature_config_fragment);

    fragment->feature_config.Set(
        feature_config_fragment.is_null() ? nullptr : feature_config_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->feature_config.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null feature_config in ModelSolutionConfig struct");

    decltype(Traits::text_safety_config(input)) in_text_safety_config = Traits::text_safety_config(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->text_safety_config)::BaseType> text_safety_config_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::mojo_base::mojom::ProtoWrapperDataView>(
      in_text_safety_config,
      text_safety_config_fragment);

    fragment->text_safety_config.Set(
        text_safety_config_fragment.is_null() ? nullptr : text_safety_config_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->text_safety_config.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null text_safety_config in ModelSolutionConfig struct");

    decltype(Traits::model_versions(input)) in_model_versions = Traits::model_versions(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->model_versions)::BaseType> model_versions_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::mojo_base::mojom::ProtoWrapperDataView>(
      in_model_versions,
      model_versions_fragment);

    fragment->model_versions.Set(
        model_versions_fragment.is_null() ? nullptr : model_versions_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->model_versions.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null model_versions in ModelSolutionConfig struct");

    decltype(Traits::model_capabilities(input)) in_model_capabilities = Traits::model_capabilities(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->model_capabilities)::BaseType> model_capabilities_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::on_device_model::mojom::CapabilitiesDataView>(
      in_model_capabilities,
      model_capabilities_fragment);

    fragment->model_capabilities.Set(
        model_capabilities_fragment.is_null() ? nullptr : model_capabilities_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->model_capabilities.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null model_capabilities in ModelSolutionConfig struct");
  }

  static bool Deserialize(::optimization_guide::mojom::internal::ModelSolutionConfig_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::optimization_guide::mojom::ModelSolutionConfigDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::optimization_guide::mojom::ModelSubscriptionOptionsDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::optimization_guide::mojom::ModelSubscriptionOptionsDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::optimization_guide::mojom::internal::ModelSubscriptionOptions_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::use_case(input)) in_use_case = Traits::use_case(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->use_case)::BaseType> use_case_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_use_case,
      use_case_fragment);

    fragment->use_case.Set(
        use_case_fragment.is_null() ? nullptr : use_case_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->use_case.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null use_case in ModelSubscriptionOptions struct");
  }

  static bool Deserialize(::optimization_guide::mojom::internal::ModelSubscriptionOptions_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::optimization_guide::mojom::ModelSubscriptionOptionsDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal

}  // namespace mojo


namespace optimization_guide::mojom {

inline void ModelSolutionConfigDataView::GetFeatureConfigDataView(
    ::mojo_base::mojom::ProtoWrapperDataView* output) {
  auto pointer = data_->feature_config.Get();
  *output = ::mojo_base::mojom::ProtoWrapperDataView(pointer, message_);
}
inline void ModelSolutionConfigDataView::GetTextSafetyConfigDataView(
    ::mojo_base::mojom::ProtoWrapperDataView* output) {
  auto pointer = data_->text_safety_config.Get();
  *output = ::mojo_base::mojom::ProtoWrapperDataView(pointer, message_);
}
inline void ModelSolutionConfigDataView::GetModelVersionsDataView(
    ::mojo_base::mojom::ProtoWrapperDataView* output) {
  auto pointer = data_->model_versions.Get();
  *output = ::mojo_base::mojom::ProtoWrapperDataView(pointer, message_);
}
inline void ModelSolutionConfigDataView::GetModelCapabilitiesDataView(
    ::on_device_model::mojom::CapabilitiesDataView* output) {
  auto pointer = data_->model_capabilities.Get();
  *output = ::on_device_model::mojom::CapabilitiesDataView(pointer, message_);
}


inline void ModelSubscriptionOptionsDataView::GetUseCaseDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->use_case.Get();
  *output = mojo::StringDataView(pointer, message_);
}



}  // optimization_guide::mojom

// Declare TraceFormatTraits for enums, which should be defined in ::perfetto
// namespace.

namespace perfetto {

template <>
struct  TraceFormatTraits<::optimization_guide::mojom::OnDeviceFeature> {
 static void WriteIntoTrace(perfetto::TracedValue context, ::optimization_guide::mojom::OnDeviceFeature value);
};

} // namespace perfetto

namespace perfetto {

template <>
struct  TraceFormatTraits<::optimization_guide::mojom::ModelUnavailableReason> {
 static void WriteIntoTrace(perfetto::TracedValue context, ::optimization_guide::mojom::ModelUnavailableReason value);
};

} // namespace perfetto

namespace perfetto {

template <>
struct  TraceFormatTraits<::optimization_guide::mojom::ModelNotSupportedDetailedReason> {
 static void WriteIntoTrace(perfetto::TracedValue context, ::optimization_guide::mojom::ModelNotSupportedDetailedReason value);
};

} // namespace perfetto

#endif  // COMPONENTS_OPTIMIZATION_GUIDE_PUBLIC_MOJOM_MODEL_BROKER_MOJOM_SHARED_H_