| // camera/mojo/camera_features.mojom.h 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. |
| |
| #ifndef CAMERA_MOJO_CAMERA_FEATURES_MOJOM_H_ |
| #define CAMERA_MOJO_CAMERA_FEATURES_MOJOM_H_ |
| |
| #include <stdint.h> |
| |
| #include <limits> |
| #include <optional> |
| #include <type_traits> |
| #include <utility> |
| |
| #include "base/types/cxx23_to_underlying.h" |
| #include "mojo/public/cpp/bindings/clone_traits.h" |
| #include "mojo/public/cpp/bindings/equals_traits.h" |
| #include "mojo/public/cpp/bindings/lib/serialization.h" |
| #include "mojo/public/cpp/bindings/struct_ptr.h" |
| #include "mojo/public/cpp/bindings/struct_traits.h" |
| #include "mojo/public/cpp/bindings/union_traits.h" |
| |
| #include "third_party/perfetto/include/perfetto/tracing/traced_value_forward.h" |
| |
| #include "camera/mojo/camera_features.mojom-features.h" |
| #include "camera/mojo/camera_features.mojom-shared.h" |
| #include "camera/mojo/camera_features.mojom-forward.h" |
| #include <string> |
| #include <vector> |
| |
| |
| |
| |
| |
| |
| |
| |
| namespace cros::mojom { |
| |
| |
| |
| |
| |
| class PortraitModeConfig { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<PortraitModeConfig, T>::value>; |
| using DataView = PortraitModeConfigDataView; |
| using Data_ = internal::PortraitModeConfig_Data; |
| |
| template <typename... Args> |
| static PortraitModeConfigPtr New(Args&&... args) { |
| return PortraitModeConfigPtr( |
| std::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static PortraitModeConfigPtr From(const U& u) { |
| return mojo::TypeConverter<PortraitModeConfigPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, PortraitModeConfig>::Convert(*this); |
| } |
| |
| |
| PortraitModeConfig(); |
| |
| explicit PortraitModeConfig( |
| bool enable_rectiface); |
| |
| |
| ~PortraitModeConfig(); |
| |
| // Clone() is a template so it is only instantiated if it is used. Thus, the |
| // bindings generator does not need to know whether Clone() or copy |
| // constructor/assignment are available for members. |
| template <typename StructPtrType = PortraitModeConfigPtr> |
| PortraitModeConfigPtr Clone() const; |
| |
| // Equals() is a template so it is only instantiated if it is used. Thus, the |
| // bindings generator does not need to know whether Equals() or == operator |
| // are available for members. |
| template <typename T, PortraitModeConfig::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, PortraitModeConfig::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| |
| template <typename T, PortraitModeConfig::EnableIfSame<T>* = nullptr> |
| bool operator!=(const T& rhs) const { return !operator==(rhs); } |
| size_t Hash(size_t seed) const; |
| template <typename UserType> |
| static std::vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| PortraitModeConfig::DataView, std::vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| PortraitModeConfig::DataView>(input); |
| } |
| |
| // The returned Message is serialized only if the message is moved |
| // cross-process or cross-language. Otherwise if the message is Deserialized |
| // as the same UserType |input| will just be moved to |output| in |
| // DeserializeFromMessage. |
| template <typename UserType> |
| static mojo::Message WrapAsMessage(UserType input) { |
| return mojo::Message(std::make_unique< |
| internal::PortraitModeConfig_UnserializedMessageContext< |
| UserType, PortraitModeConfig::DataView>>(0, 0, std::move(input)), |
| MOJO_CREATE_MESSAGE_FLAG_NONE); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| mojo::Message message; |
| return mojo::internal::DeserializeImpl<PortraitModeConfig::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const std::vector<uint8_t>& input, |
| UserType* output) { |
| return PortraitModeConfig::Deserialize( |
| input.size() == 0 ? nullptr : &input.front(), input.size(), output); |
| } |
| |
| template <typename UserType> |
| static bool DeserializeFromMessage(mojo::Message input, |
| UserType* output) { |
| auto context = input.TakeUnserializedContext< |
| internal::PortraitModeConfig_UnserializedMessageContext< |
| UserType, PortraitModeConfig::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<PortraitModeConfig::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| bool enable_rectiface; |
| |
| // Serialise this struct into a trace. |
| void WriteIntoTrace(perfetto::TracedValue traced_context) const; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| }; |
| |
| // The comparison operators are templates, so they are only instantiated if they |
| // are used. Thus, the bindings generator does not need to know whether |
| // comparison operators are available for members. |
| template <typename T, PortraitModeConfig::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, PortraitModeConfig::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, PortraitModeConfig::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, PortraitModeConfig::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| class Camera3StreamEffect { |
| public: |
| using DataView = Camera3StreamEffectDataView; |
| using Data_ = internal::Camera3StreamEffect_Data; |
| using Tag = Data_::Camera3StreamEffect_Tag; |
| |
| template <typename... Args> |
| static Camera3StreamEffectPtr New(Args&&... args) { |
| static_assert( |
| sizeof...(args) < 0, |
| "Do not use Union::New(); to create a union of a given subtype, use " |
| "New<SubType>(), not New() followed by set_<sub_type>(). To represent " |
| "an empty union, mark the field or parameter as nullable in the mojom " |
| "definition."); |
| return nullptr; |
| } |
| // Construct an instance holding |unknown_config|. |
| static Camera3StreamEffectPtr |
| NewUnknownConfig( |
| uint8_t value) { |
| auto result = Camera3StreamEffectPtr(std::in_place); |
| result->set_unknown_config(std::move(value)); |
| return result; |
| } |
| // Construct an instance holding |portrait_mode_config|. |
| static Camera3StreamEffectPtr |
| NewPortraitModeConfig( |
| PortraitModeConfigPtr value) { |
| auto result = Camera3StreamEffectPtr(std::in_place); |
| result->set_portrait_mode_config(std::move(value)); |
| return result; |
| } |
| |
| template <typename U> |
| static Camera3StreamEffectPtr From(const U& u) { |
| return mojo::TypeConverter<Camera3StreamEffectPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, Camera3StreamEffect>::Convert(*this); |
| } |
| |
| Camera3StreamEffect(); |
| ~Camera3StreamEffect(); |
| // Delete the copy constructor and copy assignment operators because `data_` |
| // contains raw pointers that must not be copied. |
| Camera3StreamEffect(const Camera3StreamEffect& other) = delete; |
| Camera3StreamEffect& operator=(const Camera3StreamEffect& other) = delete; |
| |
| // Clone() is a template so it is only instantiated if it is used. Thus, the |
| // bindings generator does not need to know whether Clone() or copy |
| // constructor/assignment are available for members. |
| template <typename UnionPtrType = Camera3StreamEffectPtr> |
| Camera3StreamEffectPtr Clone() const; |
| |
| // Equals() is a template so it is only instantiated if it is used. Thus, the |
| // bindings generator does not need to know whether Equals() or == operator |
| // are available for members. |
| template <typename T, |
| typename std::enable_if<std::is_same< |
| T, Camera3StreamEffect>::value>::type* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, |
| typename std::enable_if<std::is_same< |
| T, Camera3StreamEffect>::value>::type* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| size_t Hash(size_t seed) const; |
| |
| Tag which() const { |
| return tag_; |
| } |
| |
| |
| |
| bool is_unknown_config() const { return tag_ == Tag::kUnknownConfig; } |
| |
| |
| uint8_t get_unknown_config() const { |
| CHECK(tag_ == Tag::kUnknownConfig); |
| return data_.unknown_config; |
| } |
| |
| |
| void set_unknown_config( |
| uint8_t unknown_config); |
| |
| bool is_portrait_mode_config() const { return tag_ == Tag::kPortraitModeConfig; } |
| |
| |
| PortraitModeConfigPtr& get_portrait_mode_config() const { |
| CHECK(tag_ == Tag::kPortraitModeConfig); |
| return *(data_.portrait_mode_config); |
| } |
| |
| |
| void set_portrait_mode_config( |
| PortraitModeConfigPtr portrait_mode_config); |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| Camera3StreamEffect::DataView>(input); |
| } |
| |
| template <typename UserType> |
| static bool DeserializeFromMessage(mojo::Message input, |
| UserType* output) { |
| return mojo::internal::DeserializeImpl<Camera3StreamEffect::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| private: |
| union Union_ { |
| Union_() = default; |
| ~Union_() = default; |
| uint8_t unknown_config; |
| PortraitModeConfigPtr* portrait_mode_config; |
| }; |
| |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| |
| void DestroyActive(); |
| Tag tag_; |
| Union_ data_; |
| }; |
| |
| |
| template <typename UnionPtrType> |
| Camera3StreamEffectPtr Camera3StreamEffect::Clone() const { |
| switch (tag_) { |
| case Tag::kUnknownConfig: |
| return NewUnknownConfig( |
| mojo::Clone(data_.unknown_config)); |
| case Tag::kPortraitModeConfig: |
| return NewPortraitModeConfig( |
| mojo::Clone(*data_.portrait_mode_config)); |
| } |
| return nullptr; |
| } |
| |
| template <typename T, |
| typename std::enable_if<std::is_same< |
| T, Camera3StreamEffect>::value>::type*> |
| bool Camera3StreamEffect::Equals(const T& other) const { |
| if (tag_ != other.which()) |
| return false; |
| |
| switch (tag_) { |
| case Tag::kUnknownConfig: |
| return mojo::Equals(data_.unknown_config, other.data_.unknown_config); |
| case Tag::kPortraitModeConfig: |
| return mojo::Equals(*(data_.portrait_mode_config), *(other.data_.portrait_mode_config)); |
| } |
| |
| return false; |
| } |
| template <typename StructPtrType> |
| PortraitModeConfigPtr PortraitModeConfig::Clone() const { |
| return New( |
| mojo::Clone(enable_rectiface) |
| ); |
| } |
| |
| template <typename T, PortraitModeConfig::EnableIfSame<T>*> |
| bool PortraitModeConfig::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->enable_rectiface, other_struct.enable_rectiface)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, PortraitModeConfig::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.enable_rectiface < rhs.enable_rectiface) |
| return true; |
| if (rhs.enable_rectiface < lhs.enable_rectiface) |
| return false; |
| return false; |
| } |
| |
| |
| } // cros::mojom |
| |
| namespace mojo { |
| |
| |
| template <> |
| struct StructTraits<::cros::mojom::PortraitModeConfig::DataView, |
| ::cros::mojom::PortraitModeConfigPtr> { |
| static bool IsNull(const ::cros::mojom::PortraitModeConfigPtr& input) { return !input; } |
| static void SetToNull(::cros::mojom::PortraitModeConfigPtr* output) { output->reset(); } |
| |
| static decltype(::cros::mojom::PortraitModeConfig::enable_rectiface) enable_rectiface( |
| const ::cros::mojom::PortraitModeConfigPtr& input) { |
| return input->enable_rectiface; |
| } |
| |
| static bool Read(::cros::mojom::PortraitModeConfig::DataView input, ::cros::mojom::PortraitModeConfigPtr* output); |
| }; |
| |
| |
| template <> |
| struct UnionTraits<::cros::mojom::Camera3StreamEffect::DataView, |
| ::cros::mojom::Camera3StreamEffectPtr> { |
| static bool IsNull(const ::cros::mojom::Camera3StreamEffectPtr& input) { return !input; } |
| static void SetToNull(::cros::mojom::Camera3StreamEffectPtr* output) { output->reset(); } |
| |
| static ::cros::mojom::Camera3StreamEffect::Tag GetTag(const ::cros::mojom::Camera3StreamEffectPtr& input) { |
| return input->which(); |
| } |
| |
| static uint8_t unknown_config(const ::cros::mojom::Camera3StreamEffectPtr& input) { |
| return input->get_unknown_config(); |
| } |
| |
| static const ::cros::mojom::PortraitModeConfigPtr& portrait_mode_config(const ::cros::mojom::Camera3StreamEffectPtr& input) { |
| return input->get_portrait_mode_config(); |
| } |
| |
| static bool Read(::cros::mojom::Camera3StreamEffect::DataView input, ::cros::mojom::Camera3StreamEffectPtr* output); |
| }; |
| |
| } // namespace mojo |
| |
| #endif // CAMERA_MOJO_CAMERA_FEATURES_MOJOM_H_ |
