out/build/arm64-generic/usr/include/cros-camera/mojo/camera/mojo/camera_diagnostics.mojom-shared.h

// camera/mojo/camera_diagnostics.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 CAMERA_MOJO_CAMERA_DIAGNOSTICS_MOJOM_SHARED_H_
#define CAMERA_MOJO_CAMERA_DIAGNOSTICS_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/enum_traits.h"
#include "mojo/public/cpp/bindings/interface_data_view.h"
#include "mojo/public/cpp/bindings/lib/bindings_internal.h"
#include "mojo/public/cpp/bindings/lib/serialization.h"
#include "mojo/public/cpp/bindings/map_data_view.h"
#include "mojo/public/cpp/bindings/string_data_view.h"

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

#include "camera/mojo/camera_diagnostics.mojom-shared-internal.h"
#include "mojo/public/cpp/bindings/lib/interface_serialization.h"
#include "mojo/public/cpp/system/data_pipe.h"






namespace cros::camera_diag::mojom {
class AnalyzerResultDataView;

class DiagnosticsResultDataView;

class FrameAnalysisConfigDataView;

class CameraFrameBufferDataView;

class CameraStreamDataView;

class CameraFrameDataView;

class StreamingConfigDataView;

class FrameAnalysisResultDataView;
class StartStreamingResultDataView;


}  // cros::camera_diag::mojom

namespace mojo {
namespace internal {

template <>
struct MojomTypeTraits<::cros::camera_diag::mojom::AnalyzerResultDataView> {
  using Data = ::cros::camera_diag::mojom::internal::AnalyzerResult_Data;
  using DataAsArrayElement = Pointer<Data>;
  static constexpr MojomTypeCategory category = MojomTypeCategory::kStruct;
};

template <>
struct MojomTypeTraits<::cros::camera_diag::mojom::DiagnosticsResultDataView> {
  using Data = ::cros::camera_diag::mojom::internal::DiagnosticsResult_Data;
  using DataAsArrayElement = Pointer<Data>;
  static constexpr MojomTypeCategory category = MojomTypeCategory::kStruct;
};

template <>
struct MojomTypeTraits<::cros::camera_diag::mojom::FrameAnalysisConfigDataView> {
  using Data = ::cros::camera_diag::mojom::internal::FrameAnalysisConfig_Data;
  using DataAsArrayElement = Pointer<Data>;
  static constexpr MojomTypeCategory category = MojomTypeCategory::kStruct;
};

template <>
struct MojomTypeTraits<::cros::camera_diag::mojom::CameraFrameBufferDataView> {
  using Data = ::cros::camera_diag::mojom::internal::CameraFrameBuffer_Data;
  using DataAsArrayElement = Pointer<Data>;
  static constexpr MojomTypeCategory category = MojomTypeCategory::kStruct;
};

template <>
struct MojomTypeTraits<::cros::camera_diag::mojom::CameraStreamDataView> {
  using Data = ::cros::camera_diag::mojom::internal::CameraStream_Data;
  using DataAsArrayElement = Pointer<Data>;
  static constexpr MojomTypeCategory category = MojomTypeCategory::kStruct;
};

template <>
struct MojomTypeTraits<::cros::camera_diag::mojom::CameraFrameDataView> {
  using Data = ::cros::camera_diag::mojom::internal::CameraFrame_Data;
  using DataAsArrayElement = Pointer<Data>;
  static constexpr MojomTypeCategory category = MojomTypeCategory::kStruct;
};

template <>
struct MojomTypeTraits<::cros::camera_diag::mojom::StreamingConfigDataView> {
  using Data = ::cros::camera_diag::mojom::internal::StreamingConfig_Data;
  using DataAsArrayElement = Pointer<Data>;
  static constexpr MojomTypeCategory category = MojomTypeCategory::kStruct;
};

template <>
struct MojomTypeTraits<::cros::camera_diag::mojom::FrameAnalysisResultDataView> {
  using Data = ::cros::camera_diag::mojom::internal::FrameAnalysisResult_Data;
  using DataAsArrayElement = Data;
  static constexpr MojomTypeCategory category = MojomTypeCategory::kUnion;
};

template <>
struct MojomTypeTraits<::cros::camera_diag::mojom::StartStreamingResultDataView> {
  using Data = ::cros::camera_diag::mojom::internal::StartStreamingResult_Data;
  using DataAsArrayElement = Data;
  static constexpr MojomTypeCategory category = MojomTypeCategory::kUnion;
};

}  // namespace internal
}  // namespace mojo


namespace cros::camera_diag::mojom {


enum class AnalyzerStatus : int32_t {
  
  kNotRun = 0,
  
  kPassed = 1,
  
  kFailed = 2,
  kMinValue = 0,
  kMaxValue = 2,
};

 std::ostream& operator<<(std::ostream& os, AnalyzerStatus value);
inline bool IsKnownEnumValue(AnalyzerStatus value) {
  return internal::AnalyzerStatus_Data::IsKnownValue(
      static_cast<int32_t>(value));
}


enum class AnalyzerType : int32_t {
  
  kUnknown = 0,
  
  kPrivacyShutterSwTest = 1,
  
  kDirtyLens = 2,
  kMinValue = 0,
  kMaxValue = 2,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, AnalyzerType value);
inline bool IsKnownEnumValue(AnalyzerType value) {
  return internal::AnalyzerType_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline AnalyzerType ToKnownEnumValue(AnalyzerType value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return AnalyzerType::kDefaultValue;
}


enum class CameraIssue : int32_t {
  
  kNone = 0,
  
  kManufacturerIssue = 1,
  
  kPrivacyShutterOn = 2,
  
  kDirtyLens = 3,
  
  kCameraServiceDown = 4,
  kMinValue = 0,
  kMaxValue = 4,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, CameraIssue value);
inline bool IsKnownEnumValue(CameraIssue value) {
  return internal::CameraIssue_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline CameraIssue ToKnownEnumValue(CameraIssue value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return CameraIssue::kDefaultValue;
}


enum class ClientType : int32_t {
  
  kUnknown = 0,
  
  kHealthd = 1,
  
  kCca = 2,
  kMinValue = 0,
  kMaxValue = 2,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, ClientType value);
inline bool IsKnownEnumValue(ClientType value) {
  return internal::ClientType_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline ClientType ToKnownEnumValue(ClientType value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return ClientType::kDefaultValue;
}


enum class DataSource : int32_t {
  
  kChrome = 0,
  
  kCameraService = 1,
  
  kClientApp = 2,
  
  kCameraDiagnostics = 3,
  kMinValue = 0,
  kMaxValue = 3,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, DataSource value);
inline bool IsKnownEnumValue(DataSource value) {
  return internal::DataSource_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline DataSource ToKnownEnumValue(DataSource value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return DataSource::kDefaultValue;
}


enum class ErrorCode : int32_t {
  
  kUnknown = 0,
  
  kCameraClosed = 1,
  
  kMultipleOpenCameras = 2,
  
  kAlreadyRunningAnalysis = 3,
  
  kNotEnoughFrames = 4,
  
  kInvalidDuration = 5,
  
  kCrosCameraControllerNotRegistered = 6,
  
  kDiagnosticsInternal = 7,
  kMinValue = 0,
  kMaxValue = 7,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, ErrorCode value);
inline bool IsKnownEnumValue(ErrorCode value) {
  return internal::ErrorCode_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline ErrorCode ToKnownEnumValue(ErrorCode value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return ErrorCode::kDefaultValue;
}


enum class PixelFormat : int32_t {
  
  kYuv420 = 0,
  
  kJpeg = 1,
  kMinValue = 0,
  kMaxValue = 1,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, PixelFormat value);
inline bool IsKnownEnumValue(PixelFormat value) {
  return internal::PixelFormat_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline PixelFormat ToKnownEnumValue(PixelFormat value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return PixelFormat::kDefaultValue;
}
// Interface base classes. They are used for type safety check.
class CameraDiagnosticsInterfaceBase {};

using CameraDiagnosticsPtrDataView =
    mojo::InterfacePtrDataView<CameraDiagnosticsInterfaceBase>;
using CameraDiagnosticsRequestDataView =
    mojo::InterfaceRequestDataView<CameraDiagnosticsInterfaceBase>;
using CameraDiagnosticsAssociatedPtrInfoDataView =
    mojo::AssociatedInterfacePtrInfoDataView<CameraDiagnosticsInterfaceBase>;
using CameraDiagnosticsAssociatedRequestDataView =
    mojo::AssociatedInterfaceRequestDataView<CameraDiagnosticsInterfaceBase>;
class CrosCameraDiagnosticsServiceInterfaceBase {};

using CrosCameraDiagnosticsServicePtrDataView =
    mojo::InterfacePtrDataView<CrosCameraDiagnosticsServiceInterfaceBase>;
using CrosCameraDiagnosticsServiceRequestDataView =
    mojo::InterfaceRequestDataView<CrosCameraDiagnosticsServiceInterfaceBase>;
using CrosCameraDiagnosticsServiceAssociatedPtrInfoDataView =
    mojo::AssociatedInterfacePtrInfoDataView<CrosCameraDiagnosticsServiceInterfaceBase>;
using CrosCameraDiagnosticsServiceAssociatedRequestDataView =
    mojo::AssociatedInterfaceRequestDataView<CrosCameraDiagnosticsServiceInterfaceBase>;
class CrosCameraControllerInterfaceBase {};

using CrosCameraControllerPtrDataView =
    mojo::InterfacePtrDataView<CrosCameraControllerInterfaceBase>;
using CrosCameraControllerRequestDataView =
    mojo::InterfaceRequestDataView<CrosCameraControllerInterfaceBase>;
using CrosCameraControllerAssociatedPtrInfoDataView =
    mojo::AssociatedInterfacePtrInfoDataView<CrosCameraControllerInterfaceBase>;
using CrosCameraControllerAssociatedRequestDataView =
    mojo::AssociatedInterfaceRequestDataView<CrosCameraControllerInterfaceBase>;


class AnalyzerResultDataView {
 public:
  AnalyzerResultDataView() = default;

  AnalyzerResultDataView(
      internal::AnalyzerResult_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  [[nodiscard]] bool ReadType(UserType* output) const {
    auto data_value = data_->type;
    return mojo::internal::Deserialize<::cros::camera_diag::mojom::AnalyzerType>(
        data_value, output);
  }
  AnalyzerType type() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::cros::camera_diag::mojom::AnalyzerType>(data_->type));
  }
  template <typename UserType>
  [[nodiscard]] bool ReadStatus(UserType* output) const {
    auto data_value = data_->status;
    return mojo::internal::Deserialize<::cros::camera_diag::mojom::AnalyzerStatus>(
        data_value, output);
  }
  AnalyzerStatus status() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::cros::camera_diag::mojom::AnalyzerStatus>(data_->status));
  }
 private:
  internal::AnalyzerResult_Data* data_ = nullptr;
};


class DiagnosticsResultDataView {
 public:
  DiagnosticsResultDataView() = default;

  DiagnosticsResultDataView(
      internal::DiagnosticsResult_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  uint32_t numeber_of_analyzed_frames() const {
    return data_->numeber_of_analyzed_frames;
  }
  inline void GetAnalyzerResultsDataView(
      mojo::ArrayDataView<AnalyzerResultDataView>* output);

  template <typename UserType>
  [[nodiscard]] bool ReadAnalyzerResults(UserType* output) {
    
    auto* pointer = data_->analyzer_results.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<::cros::camera_diag::mojom::AnalyzerResultDataView>>(
        pointer, output, message_);
  }
  template <typename UserType>
  [[nodiscard]] bool ReadSuggestedIssue(UserType* output) const {
    auto data_value = data_->suggested_issue;
    return mojo::internal::Deserialize<::cros::camera_diag::mojom::CameraIssue>(
        data_value, output);
  }
  CameraIssue suggested_issue() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::cros::camera_diag::mojom::CameraIssue>(data_->suggested_issue));
  }
 private:
  internal::DiagnosticsResult_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class FrameAnalysisConfigDataView {
 public:
  FrameAnalysisConfigDataView() = default;

  FrameAnalysisConfigDataView(
      internal::FrameAnalysisConfig_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  [[nodiscard]] bool ReadClientType(UserType* output) const {
    auto data_value = data_->client_type;
    return mojo::internal::Deserialize<::cros::camera_diag::mojom::ClientType>(
        data_value, output);
  }
  ClientType client_type() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::cros::camera_diag::mojom::ClientType>(data_->client_type));
  }
  uint32_t duration_ms() const {
    return data_->duration_ms;
  }
 private:
  internal::FrameAnalysisConfig_Data* data_ = nullptr;
};


class CameraFrameBufferDataView {
 public:
  CameraFrameBufferDataView() = default;

  CameraFrameBufferDataView(
      internal::CameraFrameBuffer_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  uint32_t size() const {
    return data_->size;
  }
  mojo::ScopedSharedBufferHandle TakeShmHandle() {
    mojo::ScopedSharedBufferHandle result;
    bool ret =
        mojo::internal::Deserialize<mojo::ScopedSharedBufferHandle>(
            &data_->shm_handle, &result, message_);
    DCHECK(ret);
    return result;
  }
 private:
  internal::CameraFrameBuffer_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class CameraStreamDataView {
 public:
  CameraStreamDataView() = default;

  CameraStreamDataView(
      internal::CameraStream_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  uint32_t width() const {
    return data_->width;
  }
  uint32_t height() const {
    return data_->height;
  }
  template <typename UserType>
  [[nodiscard]] bool ReadPixelFormat(UserType* output) const {
    auto data_value = data_->pixel_format;
    return mojo::internal::Deserialize<::cros::camera_diag::mojom::PixelFormat>(
        data_value, output);
  }
  PixelFormat pixel_format() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::cros::camera_diag::mojom::PixelFormat>(data_->pixel_format));
  }
 private:
  internal::CameraStream_Data* data_ = nullptr;
};


class CameraFrameDataView {
 public:
  CameraFrameDataView() = default;

  CameraFrameDataView(
      internal::CameraFrame_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetStreamDataView(
      CameraStreamDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadStream(UserType* output) {
    
    auto* pointer = data_->stream.Get();
    return mojo::internal::Deserialize<::cros::camera_diag::mojom::CameraStreamDataView>(
        pointer, output, message_);
  }
  std::optional<uint32_t> frame_number() const {

    return data_->frame_number_$flag
        ? std::make_optional(data_->frame_number_$value)
        : std::nullopt;
  }
  template <typename UserType>
  [[nodiscard]] bool ReadSource(UserType* output) const {
    auto data_value = data_->source;
    return mojo::internal::Deserialize<::cros::camera_diag::mojom::DataSource>(
        data_value, output);
  }
  DataSource source() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::cros::camera_diag::mojom::DataSource>(data_->source));
  }
  inline void GetBufferDataView(
      CameraFrameBufferDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadBuffer(UserType* output) {
    
    auto* pointer = data_->buffer.Get();
    return mojo::internal::Deserialize<::cros::camera_diag::mojom::CameraFrameBufferDataView>(
        pointer, output, message_);
  }
  bool is_empty() const {
    return data_->is_empty;
  }
 private:
  internal::CameraFrame_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class StreamingConfigDataView {
 public:
  StreamingConfigDataView() = default;

  StreamingConfigDataView(
      internal::StreamingConfig_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  uint32_t frame_interval() const {
    return data_->frame_interval;
  }
 private:
  internal::StreamingConfig_Data* data_ = nullptr;
};


class FrameAnalysisResultDataView {
 public:
  using Tag = internal::FrameAnalysisResult_Data::FrameAnalysisResult_Tag;

  FrameAnalysisResultDataView() = default;

  FrameAnalysisResultDataView(
      internal::FrameAnalysisResult_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const {
    // For inlined unions, |data_| is always non-null. In that case we need to
    // check |data_->is_null()|.
    return !data_ || data_->is_null();
  }

  Tag tag() const { return data_->tag; }
  bool is_error() const { return data_->tag == Tag::kError; }
  template <typename UserType>
  [[nodiscard]] bool ReadError(UserType* output) const {
    CHECK(is_error());
    return mojo::internal::Deserialize<::cros::camera_diag::mojom::ErrorCode>(
        data_->data.f_error, output);
  }
  ErrorCode error() const {
    CHECK(is_error());
    // TODO(dcheng): This seems incorrect, as it bypasses enum traits.
    return ::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::cros::camera_diag::mojom::ErrorCode>(data_->data.f_error));
  }
  bool is_res() const { return data_->tag == Tag::kRes; }
  inline void GetResDataView(
      DiagnosticsResultDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadRes(UserType* output) const {
    
    CHECK(is_res());
    return mojo::internal::Deserialize<::cros::camera_diag::mojom::DiagnosticsResultDataView>(
        data_->data.f_res.Get(), output, message_);
  }

 private:
  internal::FrameAnalysisResult_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};



class StartStreamingResultDataView {
 public:
  using Tag = internal::StartStreamingResult_Data::StartStreamingResult_Tag;

  StartStreamingResultDataView() = default;

  StartStreamingResultDataView(
      internal::StartStreamingResult_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const {
    // For inlined unions, |data_| is always non-null. In that case we need to
    // check |data_->is_null()|.
    return !data_ || data_->is_null();
  }

  Tag tag() const { return data_->tag; }
  bool is_error() const { return data_->tag == Tag::kError; }
  template <typename UserType>
  [[nodiscard]] bool ReadError(UserType* output) const {
    CHECK(is_error());
    return mojo::internal::Deserialize<::cros::camera_diag::mojom::ErrorCode>(
        data_->data.f_error, output);
  }
  ErrorCode error() const {
    CHECK(is_error());
    // TODO(dcheng): This seems incorrect, as it bypasses enum traits.
    return ::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::cros::camera_diag::mojom::ErrorCode>(data_->data.f_error));
  }
  bool is_stream() const { return data_->tag == Tag::kStream; }
  inline void GetStreamDataView(
      CameraStreamDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadStream(UserType* output) const {
    
    CHECK(is_stream());
    return mojo::internal::Deserialize<::cros::camera_diag::mojom::CameraStreamDataView>(
        data_->data.f_stream.Get(), output, message_);
  }

 private:
  internal::StartStreamingResult_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};



}  // cros::camera_diag::mojom

namespace std {

template <>
struct hash<::cros::camera_diag::mojom::AnalyzerStatus>
    : public mojo::internal::EnumHashImpl<::cros::camera_diag::mojom::AnalyzerStatus> {};

template <>
struct hash<::cros::camera_diag::mojom::AnalyzerType>
    : public mojo::internal::EnumHashImpl<::cros::camera_diag::mojom::AnalyzerType> {};

template <>
struct hash<::cros::camera_diag::mojom::CameraIssue>
    : public mojo::internal::EnumHashImpl<::cros::camera_diag::mojom::CameraIssue> {};

template <>
struct hash<::cros::camera_diag::mojom::ClientType>
    : public mojo::internal::EnumHashImpl<::cros::camera_diag::mojom::ClientType> {};

template <>
struct hash<::cros::camera_diag::mojom::DataSource>
    : public mojo::internal::EnumHashImpl<::cros::camera_diag::mojom::DataSource> {};

template <>
struct hash<::cros::camera_diag::mojom::ErrorCode>
    : public mojo::internal::EnumHashImpl<::cros::camera_diag::mojom::ErrorCode> {};

template <>
struct hash<::cros::camera_diag::mojom::PixelFormat>
    : public mojo::internal::EnumHashImpl<::cros::camera_diag::mojom::PixelFormat> {};

}  // namespace std

namespace mojo {


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::cros::camera_diag::mojom::AnalyzerStatus, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::cros::camera_diag::mojom::AnalyzerStatus, 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) {
    return Traits::FromMojom(::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::cros::camera_diag::mojom::AnalyzerStatus>(input)), output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::cros::camera_diag::mojom::AnalyzerType, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::cros::camera_diag::mojom::AnalyzerType, 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) {
    return Traits::FromMojom(::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::cros::camera_diag::mojom::AnalyzerType>(input)), output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::cros::camera_diag::mojom::CameraIssue, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::cros::camera_diag::mojom::CameraIssue, 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) {
    return Traits::FromMojom(::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::cros::camera_diag::mojom::CameraIssue>(input)), output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::cros::camera_diag::mojom::ClientType, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::cros::camera_diag::mojom::ClientType, 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) {
    return Traits::FromMojom(::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::cros::camera_diag::mojom::ClientType>(input)), output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::cros::camera_diag::mojom::DataSource, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::cros::camera_diag::mojom::DataSource, 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) {
    return Traits::FromMojom(::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::cros::camera_diag::mojom::DataSource>(input)), output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::cros::camera_diag::mojom::ErrorCode, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::cros::camera_diag::mojom::ErrorCode, 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) {
    return Traits::FromMojom(::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::cros::camera_diag::mojom::ErrorCode>(input)), output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::cros::camera_diag::mojom::PixelFormat, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::cros::camera_diag::mojom::PixelFormat, 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) {
    return Traits::FromMojom(::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::cros::camera_diag::mojom::PixelFormat>(input)), output);
  }
};

}  // namespace internal


namespace internal {

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

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::cros::camera_diag::mojom::internal::AnalyzerResult_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();
    mojo::internal::Serialize<::cros::camera_diag::mojom::AnalyzerType>(
        Traits::type(input), &fragment->type);
    mojo::internal::Serialize<::cros::camera_diag::mojom::AnalyzerStatus>(
        Traits::status(input), &fragment->status);
  }

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

    ::cros::camera_diag::mojom::AnalyzerResultDataView data_view(input, message);
    return Traits::Read(data_view, output);
  }
};

}  // namespace internal


namespace internal {

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

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::cros::camera_diag::mojom::internal::DiagnosticsResult_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();
    fragment->numeber_of_analyzed_frames = Traits::numeber_of_analyzed_frames(input);
    decltype(Traits::analyzer_results(input)) in_analyzer_results = Traits::analyzer_results(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->analyzer_results)::BaseType>
        analyzer_results_fragment(fragment.message());
    constexpr const mojo::internal::ContainerValidateParams& analyzer_results_validate_params =
        mojo::internal::GetArrayValidator<0, false, nullptr>();
    mojo::internal::Serialize<mojo::ArrayDataView<::cros::camera_diag::mojom::AnalyzerResultDataView>>(
        in_analyzer_results, analyzer_results_fragment, &analyzer_results_validate_params);
    fragment->analyzer_results.Set(
        analyzer_results_fragment.is_null() ? nullptr : analyzer_results_fragment.data());
    MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
        fragment->analyzer_results.is_null(),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null analyzer_results in DiagnosticsResult struct");
    mojo::internal::Serialize<::cros::camera_diag::mojom::CameraIssue>(
        Traits::suggested_issue(input), &fragment->suggested_issue);
  }

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

    ::cros::camera_diag::mojom::DiagnosticsResultDataView data_view(input, message);
    return Traits::Read(data_view, output);
  }
};

}  // namespace internal


namespace internal {

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

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::cros::camera_diag::mojom::internal::FrameAnalysisConfig_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();
    mojo::internal::Serialize<::cros::camera_diag::mojom::ClientType>(
        Traits::client_type(input), &fragment->client_type);
    fragment->duration_ms = Traits::duration_ms(input);
  }

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

    ::cros::camera_diag::mojom::FrameAnalysisConfigDataView data_view(input, message);
    return Traits::Read(data_view, output);
  }
};

}  // namespace internal


namespace internal {

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

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::cros::camera_diag::mojom::internal::CameraFrameBuffer_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();
    fragment->size = Traits::size(input);
    decltype(Traits::shm_handle(input)) in_shm_handle = Traits::shm_handle(input);
    mojo::internal::Serialize<mojo::ScopedSharedBufferHandle>(
        in_shm_handle, &fragment->shm_handle, &fragment.message());
    MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
        !mojo::internal::IsHandleOrInterfaceValid(fragment->shm_handle),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
        "invalid shm_handle in CameraFrameBuffer struct");
  }

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

    ::cros::camera_diag::mojom::CameraFrameBufferDataView data_view(input, message);
    return Traits::Read(data_view, output);
  }
};

}  // namespace internal


namespace internal {

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

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::cros::camera_diag::mojom::internal::CameraStream_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();
    fragment->width = Traits::width(input);
    fragment->height = Traits::height(input);
    mojo::internal::Serialize<::cros::camera_diag::mojom::PixelFormat>(
        Traits::pixel_format(input), &fragment->pixel_format);
  }

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

    ::cros::camera_diag::mojom::CameraStreamDataView data_view(input, message);
    return Traits::Read(data_view, output);
  }
};

}  // namespace internal


namespace internal {

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

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::cros::camera_diag::mojom::internal::CameraFrame_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();
    decltype(Traits::stream(input)) in_stream = Traits::stream(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->stream)::BaseType> stream_fragment(
            fragment.message());
    mojo::internal::Serialize<::cros::camera_diag::mojom::CameraStreamDataView>(
        in_stream, stream_fragment);
    fragment->stream.Set(
        stream_fragment.is_null() ? nullptr : stream_fragment.data());
    MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
        fragment->stream.is_null(),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null stream in CameraFrame struct");
    fragment->frame_number_$flag = Traits::frame_number(input).has_value();
    if (Traits::frame_number(input).has_value()) {
      fragment->frame_number_$value = Traits::frame_number(input).value();
    }
    mojo::internal::Serialize<::cros::camera_diag::mojom::DataSource>(
        Traits::source(input), &fragment->source);
    decltype(Traits::buffer(input)) in_buffer = Traits::buffer(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->buffer)::BaseType> buffer_fragment(
            fragment.message());
    mojo::internal::Serialize<::cros::camera_diag::mojom::CameraFrameBufferDataView>(
        in_buffer, buffer_fragment);
    fragment->buffer.Set(
        buffer_fragment.is_null() ? nullptr : buffer_fragment.data());
    MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
        fragment->buffer.is_null(),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null buffer in CameraFrame struct");
    fragment->is_empty = Traits::is_empty(input);
  }

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

    ::cros::camera_diag::mojom::CameraFrameDataView data_view(input, message);
    return Traits::Read(data_view, output);
  }
};

}  // namespace internal


namespace internal {

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

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::cros::camera_diag::mojom::internal::StreamingConfig_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();
    fragment->frame_interval = Traits::frame_interval(input);
  }

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

    ::cros::camera_diag::mojom::StreamingConfigDataView data_view(input, message);
    return Traits::Read(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::cros::camera_diag::mojom::FrameAnalysisResultDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::cros::camera_diag::mojom::FrameAnalysisResultDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::cros::camera_diag::mojom::internal::FrameAnalysisResult_Data>& fragment,
                        bool inlined) {
    if (CallIsNullIfExists<Traits>(input)) {
       if (inlined)
        fragment->set_null();
      return;
    }

    if (!inlined)
      fragment.Allocate();

    // TODO(azani): Handle unknown and objects.
    // Set the not-null flag.
    fragment->size = kUnionDataSize;
    fragment->tag = Traits::GetTag(input);
    switch (fragment->tag) {
      case ::cros::camera_diag::mojom::FrameAnalysisResultDataView::Tag::kError: {
        decltype(Traits::error(input))
            in_error = Traits::error(input);
        mojo::internal::Serialize<::cros::camera_diag::mojom::ErrorCode>(
            in_error, &fragment->data.f_error);
        break;
      }
      case ::cros::camera_diag::mojom::FrameAnalysisResultDataView::Tag::kRes: {
        decltype(Traits::res(input))
            in_res = Traits::res(input);
        mojo::internal::MessageFragment<
            typename decltype(fragment->data.f_res)::BaseType>
            value_fragment(fragment.message());
        mojo::internal::Serialize<::cros::camera_diag::mojom::DiagnosticsResultDataView>(
            in_res, value_fragment);
        MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
            value_fragment.is_null(),
            mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
            "null res in FrameAnalysisResult union");
        fragment->data.f_res.Set(
            value_fragment.is_null() ? nullptr : value_fragment.data());
        break;
      }
    }
  }

  static bool Deserialize(::cros::camera_diag::mojom::internal::FrameAnalysisResult_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input || input->is_null())
      return CallSetToNullIfExists<Traits>(output);

    ::cros::camera_diag::mojom::FrameAnalysisResultDataView data_view(input, message);
    return Traits::Read(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::cros::camera_diag::mojom::StartStreamingResultDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::cros::camera_diag::mojom::StartStreamingResultDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::cros::camera_diag::mojom::internal::StartStreamingResult_Data>& fragment,
                        bool inlined) {
    if (CallIsNullIfExists<Traits>(input)) {
       if (inlined)
        fragment->set_null();
      return;
    }

    if (!inlined)
      fragment.Allocate();

    // TODO(azani): Handle unknown and objects.
    // Set the not-null flag.
    fragment->size = kUnionDataSize;
    fragment->tag = Traits::GetTag(input);
    switch (fragment->tag) {
      case ::cros::camera_diag::mojom::StartStreamingResultDataView::Tag::kError: {
        decltype(Traits::error(input))
            in_error = Traits::error(input);
        mojo::internal::Serialize<::cros::camera_diag::mojom::ErrorCode>(
            in_error, &fragment->data.f_error);
        break;
      }
      case ::cros::camera_diag::mojom::StartStreamingResultDataView::Tag::kStream: {
        decltype(Traits::stream(input))
            in_stream = Traits::stream(input);
        mojo::internal::MessageFragment<
            typename decltype(fragment->data.f_stream)::BaseType>
            value_fragment(fragment.message());
        mojo::internal::Serialize<::cros::camera_diag::mojom::CameraStreamDataView>(
            in_stream, value_fragment);
        MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
            value_fragment.is_null(),
            mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
            "null stream in StartStreamingResult union");
        fragment->data.f_stream.Set(
            value_fragment.is_null() ? nullptr : value_fragment.data());
        break;
      }
    }
  }

  static bool Deserialize(::cros::camera_diag::mojom::internal::StartStreamingResult_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input || input->is_null())
      return CallSetToNullIfExists<Traits>(output);

    ::cros::camera_diag::mojom::StartStreamingResultDataView data_view(input, message);
    return Traits::Read(data_view, output);
  }
};

}  // namespace internal

}  // namespace mojo


namespace cros::camera_diag::mojom {



inline void DiagnosticsResultDataView::GetAnalyzerResultsDataView(
    mojo::ArrayDataView<AnalyzerResultDataView>* output) {
  auto pointer = data_->analyzer_results.Get();
  *output = mojo::ArrayDataView<AnalyzerResultDataView>(pointer, message_);
}








inline void CameraFrameDataView::GetStreamDataView(
    CameraStreamDataView* output) {
  auto pointer = data_->stream.Get();
  *output = CameraStreamDataView(pointer, message_);
}
inline void CameraFrameDataView::GetBufferDataView(
    CameraFrameBufferDataView* output) {
  auto pointer = data_->buffer.Get();
  *output = CameraFrameBufferDataView(pointer, message_);
}




inline void FrameAnalysisResultDataView::GetResDataView(
    DiagnosticsResultDataView* output) const {
  CHECK(is_res());
  *output = DiagnosticsResultDataView(data_->data.f_res.Get(), message_);
}

inline void StartStreamingResultDataView::GetStreamDataView(
    CameraStreamDataView* output) const {
  CHECK(is_stream());
  *output = CameraStreamDataView(data_->data.f_stream.Get(), message_);
}


}  // cros::camera_diag::mojom

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

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

#endif  // CAMERA_MOJO_CAMERA_DIAGNOSTICS_MOJOM_SHARED_H_