| // chromeos/services/machine_learning/public/mojom/text_suggester.mojom.h is auto generated by mojom_bindings_generator.py, do not edit |
| |
| // Copyright 2013 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef CHROMEOS_SERVICES_MACHINE_LEARNING_PUBLIC_MOJOM_TEXT_SUGGESTER_MOJOM_H_ |
| #define CHROMEOS_SERVICES_MACHINE_LEARNING_PUBLIC_MOJOM_TEXT_SUGGESTER_MOJOM_H_ |
| |
| #include <stdint.h> |
| |
| #include <limits> |
| #include <type_traits> |
| #include <utility> |
| |
| #include "third_party/abseil-cpp/absl/types/optional.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 "chromeos/services/machine_learning/public/mojom/text_suggester.mojom-shared.h" |
| #include "chromeos/services/machine_learning/public/mojom/text_suggester.mojom-forward.h" |
| #include <string> |
| #include <vector> |
| |
| #include "mojo/public/cpp/bindings/lib/control_message_handler.h" |
| #include "mojo/public/cpp/bindings/raw_ptr_impl_ref_traits.h" |
| |
| |
| #include "base/component_export.h" |
| |
| #ifdef KYTHE_IS_RUNNING |
| #pragma kythe_inline_metadata "Metadata comment" |
| #endif |
| |
| |
| namespace chromeos { |
| namespace machine_learning { |
| namespace mojom { |
| |
| class TextSuggesterProxy; |
| |
| template <typename ImplRefTraits> |
| class TextSuggesterStub; |
| |
| class TextSuggesterRequestValidator; |
| class TextSuggesterResponseValidator; |
| |
| |
| // @generated_from: chromeos.machine_learning.mojom.TextSuggester |
| class COMPONENT_EXPORT(MLSERVICE_MOJOM) TextSuggester |
| : public TextSuggesterInterfaceBase { |
| public: |
| static const char Name_[]; |
| static std::pair<uint32_t, const void*> MessageToMethodInfo_(mojo::Message& message); |
| static const char* MessageToMethodName_(mojo::Message& message); |
| static constexpr uint32_t Version_ = 0; |
| static constexpr bool PassesAssociatedKinds_ = false; |
| static constexpr bool HasSyncMethods_ = false; |
| static constexpr bool HasUninterruptableMethods_ = false; |
| |
| using Base_ = TextSuggesterInterfaceBase; |
| using Proxy_ = TextSuggesterProxy; |
| |
| template <typename ImplRefTraits> |
| using Stub_ = TextSuggesterStub<ImplRefTraits>; |
| |
| using RequestValidator_ = TextSuggesterRequestValidator; |
| using ResponseValidator_ = TextSuggesterResponseValidator; |
| enum MethodMinVersions : uint32_t { |
| kSuggestMinVersion = 0, |
| }; |
| |
| // crbug.com/1340245 - this causes binary size bloat on Fuchsia, and we're OK |
| // with not having this data in traces there. |
| #if !BUILDFLAG(IS_FUCHSIA) |
| struct Suggest_Sym { |
| NOINLINE static void IPCSymbol(); |
| }; |
| #endif // !BUILDFLAG(IS_FUCHSIA) |
| virtual ~TextSuggester() = default; |
| |
| |
| using SuggestCallback = base::OnceCallback<void(TextSuggesterResultPtr)>; |
| |
| // @generated_from: chromeos.machine_learning.mojom.TextSuggester.Suggest |
| virtual void Suggest(TextSuggesterQueryPtr query, SuggestCallback callback) = 0; |
| }; |
| |
| |
| |
| // @generated_from: chromeos.machine_learning.mojom.TextSuggester |
| class COMPONENT_EXPORT(MLSERVICE_MOJOM) TextSuggesterProxy |
| : public TextSuggester { |
| public: |
| using InterfaceType = TextSuggester; |
| |
| explicit TextSuggesterProxy(mojo::MessageReceiverWithResponder* receiver); |
| |
| // @generated_from: chromeos.machine_learning.mojom.TextSuggester.Suggest |
| void Suggest(TextSuggesterQueryPtr query, SuggestCallback callback) final; |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| class COMPONENT_EXPORT(MLSERVICE_MOJOM) TextSuggesterStubDispatch { |
| public: |
| static bool Accept(TextSuggester* impl, mojo::Message* message); |
| static bool AcceptWithResponder( |
| TextSuggester* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder); |
| }; |
| |
| template <typename ImplRefTraits = |
| mojo::RawPtrImplRefTraits<TextSuggester>> |
| class TextSuggesterStub |
| : public mojo::MessageReceiverWithResponderStatus { |
| public: |
| using ImplPointerType = typename ImplRefTraits::PointerType; |
| |
| TextSuggesterStub() = default; |
| ~TextSuggesterStub() override = default; |
| |
| void set_sink(ImplPointerType sink) { sink_ = std::move(sink); } |
| ImplPointerType& sink() { return sink_; } |
| |
| bool Accept(mojo::Message* message) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return TextSuggesterStubDispatch::Accept( |
| ImplRefTraits::GetRawPointer(&sink_), message); |
| } |
| |
| bool AcceptWithResponder( |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return TextSuggesterStubDispatch::AcceptWithResponder( |
| ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); |
| } |
| |
| private: |
| ImplPointerType sink_; |
| }; |
| class COMPONENT_EXPORT(MLSERVICE_MOJOM) TextSuggesterRequestValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class COMPONENT_EXPORT(MLSERVICE_MOJOM) TextSuggesterResponseValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| |
| |
| |
| |
| |
| // @generated_from: chromeos.machine_learning.mojom.NextWordCompletionCandidate |
| class COMPONENT_EXPORT(MLSERVICE_MOJOM) NextWordCompletionCandidate { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<NextWordCompletionCandidate, T>::value>; |
| using DataView = NextWordCompletionCandidateDataView; |
| using Data_ = internal::NextWordCompletionCandidate_Data; |
| |
| template <typename... Args> |
| static NextWordCompletionCandidatePtr New(Args&&... args) { |
| return NextWordCompletionCandidatePtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static NextWordCompletionCandidatePtr From(const U& u) { |
| return mojo::TypeConverter<NextWordCompletionCandidatePtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, NextWordCompletionCandidate>::Convert(*this); |
| } |
| |
| |
| NextWordCompletionCandidate(); |
| |
| NextWordCompletionCandidate( |
| const std::string& text, |
| float normalized_score); |
| |
| |
| ~NextWordCompletionCandidate(); |
| |
| // 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 = NextWordCompletionCandidatePtr> |
| NextWordCompletionCandidatePtr 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, NextWordCompletionCandidate::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, NextWordCompletionCandidate::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| size_t Hash(size_t seed) const; |
| template <typename UserType> |
| static std::vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| NextWordCompletionCandidate::DataView, std::vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| NextWordCompletionCandidate::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::NextWordCompletionCandidate_UnserializedMessageContext< |
| UserType, NextWordCompletionCandidate::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<NextWordCompletionCandidate::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const std::vector<uint8_t>& input, |
| UserType* output) { |
| return NextWordCompletionCandidate::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::NextWordCompletionCandidate_UnserializedMessageContext< |
| UserType, NextWordCompletionCandidate::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<NextWordCompletionCandidate::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: chromeos.machine_learning.mojom.NextWordCompletionCandidate.text |
| std::string text; |
| |
| // @generated_from: chromeos.machine_learning.mojom.NextWordCompletionCandidate.normalized_score |
| float normalized_score; |
| |
| // 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, NextWordCompletionCandidate::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, NextWordCompletionCandidate::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, NextWordCompletionCandidate::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, NextWordCompletionCandidate::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| |
| // @generated_from: chromeos.machine_learning.mojom.MultiWordSuggestionCandidate |
| class COMPONENT_EXPORT(MLSERVICE_MOJOM) MultiWordSuggestionCandidate { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<MultiWordSuggestionCandidate, T>::value>; |
| using DataView = MultiWordSuggestionCandidateDataView; |
| using Data_ = internal::MultiWordSuggestionCandidate_Data; |
| |
| template <typename... Args> |
| static MultiWordSuggestionCandidatePtr New(Args&&... args) { |
| return MultiWordSuggestionCandidatePtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static MultiWordSuggestionCandidatePtr From(const U& u) { |
| return mojo::TypeConverter<MultiWordSuggestionCandidatePtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, MultiWordSuggestionCandidate>::Convert(*this); |
| } |
| |
| |
| MultiWordSuggestionCandidate(); |
| |
| MultiWordSuggestionCandidate( |
| const std::string& text, |
| float normalized_score); |
| |
| |
| ~MultiWordSuggestionCandidate(); |
| |
| // 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 = MultiWordSuggestionCandidatePtr> |
| MultiWordSuggestionCandidatePtr 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, MultiWordSuggestionCandidate::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, MultiWordSuggestionCandidate::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| size_t Hash(size_t seed) const; |
| template <typename UserType> |
| static std::vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| MultiWordSuggestionCandidate::DataView, std::vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| MultiWordSuggestionCandidate::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::MultiWordSuggestionCandidate_UnserializedMessageContext< |
| UserType, MultiWordSuggestionCandidate::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<MultiWordSuggestionCandidate::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const std::vector<uint8_t>& input, |
| UserType* output) { |
| return MultiWordSuggestionCandidate::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::MultiWordSuggestionCandidate_UnserializedMessageContext< |
| UserType, MultiWordSuggestionCandidate::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<MultiWordSuggestionCandidate::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: chromeos.machine_learning.mojom.MultiWordSuggestionCandidate.text |
| std::string text; |
| |
| // @generated_from: chromeos.machine_learning.mojom.MultiWordSuggestionCandidate.normalized_score |
| float normalized_score; |
| |
| // 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, MultiWordSuggestionCandidate::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, MultiWordSuggestionCandidate::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, MultiWordSuggestionCandidate::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, MultiWordSuggestionCandidate::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| |
| // @generated_from: chromeos.machine_learning.mojom.TextSuggesterSpec |
| class COMPONENT_EXPORT(MLSERVICE_MOJOM) TextSuggesterSpec { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<TextSuggesterSpec, T>::value>; |
| using DataView = TextSuggesterSpecDataView; |
| using Data_ = internal::TextSuggesterSpec_Data; |
| |
| template <typename... Args> |
| static TextSuggesterSpecPtr New(Args&&... args) { |
| return TextSuggesterSpecPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static TextSuggesterSpecPtr From(const U& u) { |
| return mojo::TypeConverter<TextSuggesterSpecPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, TextSuggesterSpec>::Convert(*this); |
| } |
| |
| |
| TextSuggesterSpec(); |
| |
| explicit TextSuggesterSpec( |
| MultiWordExperimentGroup multi_word_experiment); |
| |
| |
| ~TextSuggesterSpec(); |
| |
| // 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 = TextSuggesterSpecPtr> |
| TextSuggesterSpecPtr 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, TextSuggesterSpec::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, TextSuggesterSpec::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| size_t Hash(size_t seed) const; |
| template <typename UserType> |
| static std::vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| TextSuggesterSpec::DataView, std::vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| TextSuggesterSpec::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::TextSuggesterSpec_UnserializedMessageContext< |
| UserType, TextSuggesterSpec::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<TextSuggesterSpec::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const std::vector<uint8_t>& input, |
| UserType* output) { |
| return TextSuggesterSpec::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::TextSuggesterSpec_UnserializedMessageContext< |
| UserType, TextSuggesterSpec::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<TextSuggesterSpec::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: chromeos.machine_learning.mojom.TextSuggesterSpec.multi_word_experiment |
| MultiWordExperimentGroup multi_word_experiment; |
| |
| // 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, TextSuggesterSpec::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, TextSuggesterSpec::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, TextSuggesterSpec::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, TextSuggesterSpec::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: chromeos.machine_learning.mojom.TextSuggestionCandidate |
| class COMPONENT_EXPORT(MLSERVICE_MOJOM) TextSuggestionCandidate { |
| public: |
| using DataView = TextSuggestionCandidateDataView; |
| using Data_ = internal::TextSuggestionCandidate_Data; |
| using Tag = Data_::TextSuggestionCandidate_Tag; |
| |
| template <typename... Args> |
| static TextSuggestionCandidatePtr 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."); |
| } |
| // Construct an instance holding |multi_word|. |
| static TextSuggestionCandidatePtr |
| NewMultiWord( |
| MultiWordSuggestionCandidatePtr multi_word) { |
| auto result = TextSuggestionCandidatePtr(absl::in_place); |
| result->set_multi_word(std::move(multi_word)); |
| return result; |
| } |
| |
| template <typename U> |
| static TextSuggestionCandidatePtr From(const U& u) { |
| return mojo::TypeConverter<TextSuggestionCandidatePtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, TextSuggestionCandidate>::Convert(*this); |
| } |
| |
| TextSuggestionCandidate(); |
| ~TextSuggestionCandidate(); |
| |
| // 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 = TextSuggestionCandidatePtr> |
| TextSuggestionCandidatePtr 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, TextSuggestionCandidate>::value>::type* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, |
| typename std::enable_if<std::is_same< |
| T, TextSuggestionCandidate>::value>::type* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| size_t Hash(size_t seed) const; |
| |
| Tag which() const { |
| return tag_; |
| } |
| |
| |
| |
| // @generated_from: chromeos.machine_learning.mojom.TextSuggestionCandidate.multi_word |
| bool is_multi_word() const { return tag_ == Tag::kMultiWord; } |
| |
| |
| // @generated_from: chromeos.machine_learning.mojom.TextSuggestionCandidate.multi_word |
| MultiWordSuggestionCandidatePtr& get_multi_word() const { |
| CHECK(tag_ == Tag::kMultiWord); |
| return *(data_.multi_word); |
| } |
| |
| |
| // @generated_from: chromeos.machine_learning.mojom.TextSuggestionCandidate.multi_word |
| void set_multi_word( |
| MultiWordSuggestionCandidatePtr multi_word); |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| TextSuggestionCandidate::DataView>(input); |
| } |
| |
| template <typename UserType> |
| static bool DeserializeFromMessage(mojo::Message input, |
| UserType* output) { |
| return mojo::internal::DeserializeImpl<TextSuggestionCandidate::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| private: |
| union Union_ { |
| Union_() = default; |
| ~Union_() = default; |
| MultiWordSuggestionCandidatePtr* multi_word; |
| }; |
| |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| |
| void DestroyActive(); |
| Tag tag_; |
| Union_ data_; |
| }; |
| |
| |
| |
| |
| |
| |
| // @generated_from: chromeos.machine_learning.mojom.TextSuggesterQuery |
| class COMPONENT_EXPORT(MLSERVICE_MOJOM) TextSuggesterQuery { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<TextSuggesterQuery, T>::value>; |
| using DataView = TextSuggesterQueryDataView; |
| using Data_ = internal::TextSuggesterQuery_Data; |
| |
| template <typename... Args> |
| static TextSuggesterQueryPtr New(Args&&... args) { |
| return TextSuggesterQueryPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static TextSuggesterQueryPtr From(const U& u) { |
| return mojo::TypeConverter<TextSuggesterQueryPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, TextSuggesterQuery>::Convert(*this); |
| } |
| |
| |
| TextSuggesterQuery(); |
| |
| TextSuggesterQuery( |
| const std::string& text, |
| std::vector<NextWordCompletionCandidatePtr> next_word_candidates); |
| |
| TextSuggesterQuery( |
| const std::string& text, |
| std::vector<NextWordCompletionCandidatePtr> next_word_candidates, |
| TextSuggestionMode suggestion_mode); |
| |
| TextSuggesterQuery(const TextSuggesterQuery&) = delete; |
| TextSuggesterQuery& operator=(const TextSuggesterQuery&) = delete; |
| |
| ~TextSuggesterQuery(); |
| |
| // 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 = TextSuggesterQueryPtr> |
| TextSuggesterQueryPtr 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, TextSuggesterQuery::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, TextSuggesterQuery::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| template <typename UserType> |
| static std::vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| TextSuggesterQuery::DataView, std::vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| TextSuggesterQuery::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::TextSuggesterQuery_UnserializedMessageContext< |
| UserType, TextSuggesterQuery::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<TextSuggesterQuery::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const std::vector<uint8_t>& input, |
| UserType* output) { |
| return TextSuggesterQuery::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::TextSuggesterQuery_UnserializedMessageContext< |
| UserType, TextSuggesterQuery::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<TextSuggesterQuery::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: chromeos.machine_learning.mojom.TextSuggesterQuery.text |
| std::string text; |
| |
| // @generated_from: chromeos.machine_learning.mojom.TextSuggesterQuery.next_word_candidates |
| std::vector<NextWordCompletionCandidatePtr> next_word_candidates; |
| |
| // @generated_from: chromeos.machine_learning.mojom.TextSuggesterQuery.suggestion_mode |
| TextSuggestionMode suggestion_mode; |
| |
| // 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, TextSuggesterQuery::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, TextSuggesterQuery::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, TextSuggesterQuery::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, TextSuggesterQuery::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| |
| // @generated_from: chromeos.machine_learning.mojom.TextSuggesterResult |
| class COMPONENT_EXPORT(MLSERVICE_MOJOM) TextSuggesterResult { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<TextSuggesterResult, T>::value>; |
| using DataView = TextSuggesterResultDataView; |
| using Data_ = internal::TextSuggesterResult_Data; |
| // @generated_from: chromeos.machine_learning.mojom.TextSuggesterResult.Status |
| using Status = TextSuggesterResult_Status; |
| |
| template <typename... Args> |
| static TextSuggesterResultPtr New(Args&&... args) { |
| return TextSuggesterResultPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static TextSuggesterResultPtr From(const U& u) { |
| return mojo::TypeConverter<TextSuggesterResultPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, TextSuggesterResult>::Convert(*this); |
| } |
| |
| |
| TextSuggesterResult(); |
| |
| TextSuggesterResult( |
| TextSuggesterResult::Status status, |
| std::vector<TextSuggestionCandidatePtr> candidates); |
| |
| TextSuggesterResult(const TextSuggesterResult&) = delete; |
| TextSuggesterResult& operator=(const TextSuggesterResult&) = delete; |
| |
| ~TextSuggesterResult(); |
| |
| // 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 = TextSuggesterResultPtr> |
| TextSuggesterResultPtr 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, TextSuggesterResult::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, TextSuggesterResult::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| template <typename UserType> |
| static std::vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| TextSuggesterResult::DataView, std::vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| TextSuggesterResult::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::TextSuggesterResult_UnserializedMessageContext< |
| UserType, TextSuggesterResult::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<TextSuggesterResult::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const std::vector<uint8_t>& input, |
| UserType* output) { |
| return TextSuggesterResult::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::TextSuggesterResult_UnserializedMessageContext< |
| UserType, TextSuggesterResult::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<TextSuggesterResult::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: chromeos.machine_learning.mojom.TextSuggesterResult.status |
| TextSuggesterResult::Status status; |
| |
| // @generated_from: chromeos.machine_learning.mojom.TextSuggesterResult.candidates |
| std::vector<TextSuggestionCandidatePtr> candidates; |
| |
| // 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, TextSuggesterResult::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, TextSuggesterResult::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, TextSuggesterResult::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, TextSuggesterResult::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| template <typename UnionPtrType> |
| TextSuggestionCandidatePtr TextSuggestionCandidate::Clone() const { |
| switch (tag_) { |
| case Tag::kMultiWord: |
| return NewMultiWord( |
| mojo::Clone(*data_.multi_word)); |
| } |
| return nullptr; |
| } |
| |
| template <typename T, |
| typename std::enable_if<std::is_same< |
| T, TextSuggestionCandidate>::value>::type*> |
| bool TextSuggestionCandidate::Equals(const T& other) const { |
| if (tag_ != other.which()) |
| return false; |
| |
| switch (tag_) { |
| case Tag::kMultiWord: |
| return mojo::Equals(*(data_.multi_word), *(other.data_.multi_word)); |
| } |
| |
| return false; |
| } |
| template <typename StructPtrType> |
| NextWordCompletionCandidatePtr NextWordCompletionCandidate::Clone() const { |
| return New( |
| mojo::Clone(text), |
| mojo::Clone(normalized_score) |
| ); |
| } |
| |
| template <typename T, NextWordCompletionCandidate::EnableIfSame<T>*> |
| bool NextWordCompletionCandidate::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->text, other_struct.text)) |
| return false; |
| if (!mojo::Equals(this->normalized_score, other_struct.normalized_score)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, NextWordCompletionCandidate::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.text < rhs.text) |
| return true; |
| if (rhs.text < lhs.text) |
| return false; |
| if (lhs.normalized_score < rhs.normalized_score) |
| return true; |
| if (rhs.normalized_score < lhs.normalized_score) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| TextSuggesterQueryPtr TextSuggesterQuery::Clone() const { |
| return New( |
| mojo::Clone(text), |
| mojo::Clone(next_word_candidates), |
| mojo::Clone(suggestion_mode) |
| ); |
| } |
| |
| template <typename T, TextSuggesterQuery::EnableIfSame<T>*> |
| bool TextSuggesterQuery::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->text, other_struct.text)) |
| return false; |
| if (!mojo::Equals(this->next_word_candidates, other_struct.next_word_candidates)) |
| return false; |
| if (!mojo::Equals(this->suggestion_mode, other_struct.suggestion_mode)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, TextSuggesterQuery::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.text < rhs.text) |
| return true; |
| if (rhs.text < lhs.text) |
| return false; |
| if (lhs.next_word_candidates < rhs.next_word_candidates) |
| return true; |
| if (rhs.next_word_candidates < lhs.next_word_candidates) |
| return false; |
| if (lhs.suggestion_mode < rhs.suggestion_mode) |
| return true; |
| if (rhs.suggestion_mode < lhs.suggestion_mode) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| MultiWordSuggestionCandidatePtr MultiWordSuggestionCandidate::Clone() const { |
| return New( |
| mojo::Clone(text), |
| mojo::Clone(normalized_score) |
| ); |
| } |
| |
| template <typename T, MultiWordSuggestionCandidate::EnableIfSame<T>*> |
| bool MultiWordSuggestionCandidate::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->text, other_struct.text)) |
| return false; |
| if (!mojo::Equals(this->normalized_score, other_struct.normalized_score)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, MultiWordSuggestionCandidate::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.text < rhs.text) |
| return true; |
| if (rhs.text < lhs.text) |
| return false; |
| if (lhs.normalized_score < rhs.normalized_score) |
| return true; |
| if (rhs.normalized_score < lhs.normalized_score) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| TextSuggesterResultPtr TextSuggesterResult::Clone() const { |
| return New( |
| mojo::Clone(status), |
| mojo::Clone(candidates) |
| ); |
| } |
| |
| template <typename T, TextSuggesterResult::EnableIfSame<T>*> |
| bool TextSuggesterResult::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->status, other_struct.status)) |
| return false; |
| if (!mojo::Equals(this->candidates, other_struct.candidates)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, TextSuggesterResult::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.status < rhs.status) |
| return true; |
| if (rhs.status < lhs.status) |
| return false; |
| if (lhs.candidates < rhs.candidates) |
| return true; |
| if (rhs.candidates < lhs.candidates) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| TextSuggesterSpecPtr TextSuggesterSpec::Clone() const { |
| return New( |
| mojo::Clone(multi_word_experiment) |
| ); |
| } |
| |
| template <typename T, TextSuggesterSpec::EnableIfSame<T>*> |
| bool TextSuggesterSpec::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->multi_word_experiment, other_struct.multi_word_experiment)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, TextSuggesterSpec::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.multi_word_experiment < rhs.multi_word_experiment) |
| return true; |
| if (rhs.multi_word_experiment < lhs.multi_word_experiment) |
| return false; |
| return false; |
| } |
| |
| |
| } // namespace mojom |
| } // namespace machine_learning |
| } // namespace chromeos |
| |
| namespace mojo { |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(MLSERVICE_MOJOM) StructTraits<::chromeos::machine_learning::mojom::NextWordCompletionCandidate::DataView, |
| ::chromeos::machine_learning::mojom::NextWordCompletionCandidatePtr> { |
| static bool IsNull(const ::chromeos::machine_learning::mojom::NextWordCompletionCandidatePtr& input) { return !input; } |
| static void SetToNull(::chromeos::machine_learning::mojom::NextWordCompletionCandidatePtr* output) { output->reset(); } |
| |
| static const decltype(::chromeos::machine_learning::mojom::NextWordCompletionCandidate::text)& text( |
| const ::chromeos::machine_learning::mojom::NextWordCompletionCandidatePtr& input) { |
| return input->text; |
| } |
| |
| static decltype(::chromeos::machine_learning::mojom::NextWordCompletionCandidate::normalized_score) normalized_score( |
| const ::chromeos::machine_learning::mojom::NextWordCompletionCandidatePtr& input) { |
| return input->normalized_score; |
| } |
| |
| static bool Read(::chromeos::machine_learning::mojom::NextWordCompletionCandidate::DataView input, ::chromeos::machine_learning::mojom::NextWordCompletionCandidatePtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(MLSERVICE_MOJOM) StructTraits<::chromeos::machine_learning::mojom::TextSuggesterQuery::DataView, |
| ::chromeos::machine_learning::mojom::TextSuggesterQueryPtr> { |
| static bool IsNull(const ::chromeos::machine_learning::mojom::TextSuggesterQueryPtr& input) { return !input; } |
| static void SetToNull(::chromeos::machine_learning::mojom::TextSuggesterQueryPtr* output) { output->reset(); } |
| |
| static const decltype(::chromeos::machine_learning::mojom::TextSuggesterQuery::text)& text( |
| const ::chromeos::machine_learning::mojom::TextSuggesterQueryPtr& input) { |
| return input->text; |
| } |
| |
| static const decltype(::chromeos::machine_learning::mojom::TextSuggesterQuery::next_word_candidates)& next_word_candidates( |
| const ::chromeos::machine_learning::mojom::TextSuggesterQueryPtr& input) { |
| return input->next_word_candidates; |
| } |
| |
| static decltype(::chromeos::machine_learning::mojom::TextSuggesterQuery::suggestion_mode) suggestion_mode( |
| const ::chromeos::machine_learning::mojom::TextSuggesterQueryPtr& input) { |
| return input->suggestion_mode; |
| } |
| |
| static bool Read(::chromeos::machine_learning::mojom::TextSuggesterQuery::DataView input, ::chromeos::machine_learning::mojom::TextSuggesterQueryPtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(MLSERVICE_MOJOM) StructTraits<::chromeos::machine_learning::mojom::MultiWordSuggestionCandidate::DataView, |
| ::chromeos::machine_learning::mojom::MultiWordSuggestionCandidatePtr> { |
| static bool IsNull(const ::chromeos::machine_learning::mojom::MultiWordSuggestionCandidatePtr& input) { return !input; } |
| static void SetToNull(::chromeos::machine_learning::mojom::MultiWordSuggestionCandidatePtr* output) { output->reset(); } |
| |
| static const decltype(::chromeos::machine_learning::mojom::MultiWordSuggestionCandidate::text)& text( |
| const ::chromeos::machine_learning::mojom::MultiWordSuggestionCandidatePtr& input) { |
| return input->text; |
| } |
| |
| static decltype(::chromeos::machine_learning::mojom::MultiWordSuggestionCandidate::normalized_score) normalized_score( |
| const ::chromeos::machine_learning::mojom::MultiWordSuggestionCandidatePtr& input) { |
| return input->normalized_score; |
| } |
| |
| static bool Read(::chromeos::machine_learning::mojom::MultiWordSuggestionCandidate::DataView input, ::chromeos::machine_learning::mojom::MultiWordSuggestionCandidatePtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(MLSERVICE_MOJOM) StructTraits<::chromeos::machine_learning::mojom::TextSuggesterResult::DataView, |
| ::chromeos::machine_learning::mojom::TextSuggesterResultPtr> { |
| static bool IsNull(const ::chromeos::machine_learning::mojom::TextSuggesterResultPtr& input) { return !input; } |
| static void SetToNull(::chromeos::machine_learning::mojom::TextSuggesterResultPtr* output) { output->reset(); } |
| |
| static decltype(::chromeos::machine_learning::mojom::TextSuggesterResult::status) status( |
| const ::chromeos::machine_learning::mojom::TextSuggesterResultPtr& input) { |
| return input->status; |
| } |
| |
| static const decltype(::chromeos::machine_learning::mojom::TextSuggesterResult::candidates)& candidates( |
| const ::chromeos::machine_learning::mojom::TextSuggesterResultPtr& input) { |
| return input->candidates; |
| } |
| |
| static bool Read(::chromeos::machine_learning::mojom::TextSuggesterResult::DataView input, ::chromeos::machine_learning::mojom::TextSuggesterResultPtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(MLSERVICE_MOJOM) StructTraits<::chromeos::machine_learning::mojom::TextSuggesterSpec::DataView, |
| ::chromeos::machine_learning::mojom::TextSuggesterSpecPtr> { |
| static bool IsNull(const ::chromeos::machine_learning::mojom::TextSuggesterSpecPtr& input) { return !input; } |
| static void SetToNull(::chromeos::machine_learning::mojom::TextSuggesterSpecPtr* output) { output->reset(); } |
| |
| static decltype(::chromeos::machine_learning::mojom::TextSuggesterSpec::multi_word_experiment) multi_word_experiment( |
| const ::chromeos::machine_learning::mojom::TextSuggesterSpecPtr& input) { |
| return input->multi_word_experiment; |
| } |
| |
| static bool Read(::chromeos::machine_learning::mojom::TextSuggesterSpec::DataView input, ::chromeos::machine_learning::mojom::TextSuggesterSpecPtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(MLSERVICE_MOJOM) UnionTraits<::chromeos::machine_learning::mojom::TextSuggestionCandidate::DataView, |
| ::chromeos::machine_learning::mojom::TextSuggestionCandidatePtr> { |
| static bool IsNull(const ::chromeos::machine_learning::mojom::TextSuggestionCandidatePtr& input) { return !input; } |
| static void SetToNull(::chromeos::machine_learning::mojom::TextSuggestionCandidatePtr* output) { output->reset(); } |
| |
| static ::chromeos::machine_learning::mojom::TextSuggestionCandidate::Tag GetTag(const ::chromeos::machine_learning::mojom::TextSuggestionCandidatePtr& input) { |
| return input->which(); |
| } |
| |
| static const ::chromeos::machine_learning::mojom::MultiWordSuggestionCandidatePtr& multi_word(const ::chromeos::machine_learning::mojom::TextSuggestionCandidatePtr& input) { |
| return input->get_multi_word(); |
| } |
| |
| static bool Read(::chromeos::machine_learning::mojom::TextSuggestionCandidate::DataView input, ::chromeos::machine_learning::mojom::TextSuggestionCandidatePtr* output); |
| }; |
| |
| } // namespace mojo |
| |
| #endif // CHROMEOS_SERVICES_MACHINE_LEARNING_PUBLIC_MOJOM_TEXT_SUGGESTER_MOJOM_H_ |
| |
| /* Metadata comment |
| eyJtZXRhIjogW3siZW5kIjogMTgxMSwgImJlZ2luIjogMTc5OCwgImVkZ2UiOiAiJS9reXRoZS9l |
| ZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3Jw |
| dXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2Ui |
| OiAibW9qb20iLCAic2lnbmF0dXJlIjogImNocm9tZW9zLm1hY2hpbmVfbGVhcm5pbmcubW9qb20u |
| VGV4dFN1Z2dlc3RlciJ9fSwgeyJlbmQiOiAzMDgxLCAiYmVnaW4iOiAzMDc0LCAiZWRnZSI6ICIl |
| L2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUi |
| OiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJs |
| YW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY2hyb21lb3MubWFjaGluZV9sZWFybmlu |
| Zy5tb2pvbS5UZXh0U3VnZ2VzdGVyLlN1Z2dlc3QifX0sIHsiZW5kIjogMzUxOSwgImJlZ2luIjog |
| MzUxMiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9k |
| ZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9j |
| aHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImNocm9tZW9z |
| Lm1hY2hpbmVfbGVhcm5pbmcubW9qb20uVGV4dFN1Z2dlc3Rlci5TdWdnZXN0In19LCB7ImVuZCI6 |
| IDU0NTEsICJiZWdpbiI6IDU0MjQsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAi |
| dHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdv |
| b2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25h |
| dHVyZSI6ICJjaHJvbWVvcy5tYWNoaW5lX2xlYXJuaW5nLm1vam9tLk5leHRXb3JkQ29tcGxldGlv |
| bkNhbmRpZGF0ZSJ9fSwgeyJlbmQiOiA5NTA0LCAiYmVnaW4iOiA5NTAwLCAiZWRnZSI6ICIlL2t5 |
| dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7 |
| ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5n |
| dWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY2hyb21lb3MubWFjaGluZV9sZWFybmluZy5t |
| b2pvbS5OZXh0V29yZENvbXBsZXRpb25DYW5kaWRhdGUudGV4dCJ9fSwgeyJlbmQiOiA5NjMwLCAi |
| YmVnaW4iOiA5NjE0LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAi |
| YW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3Vy |
| Y2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAi |
| Y2hyb21lb3MubWFjaGluZV9sZWFybmluZy5tb2pvbS5OZXh0V29yZENvbXBsZXRpb25DYW5kaWRh |
| dGUubm9ybWFsaXplZF9zY29yZSJ9fSwgeyJlbmQiOiAxMDgwNywgImJlZ2luIjogMTA3NzksICJl |
| ZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIs |
| ICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0v |
| c3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJjaHJvbWVvcy5tYWNoaW5l |
| X2xlYXJuaW5nLm1vam9tLk11bHRpV29yZFN1Z2dlc3Rpb25DYW5kaWRhdGUifX0sIHsiZW5kIjog |
| MTQ4ODUsICJiZWdpbiI6IDE0ODgxLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwg |
| InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5n |
| b29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWdu |
| YXR1cmUiOiAiY2hyb21lb3MubWFjaGluZV9sZWFybmluZy5tb2pvbS5NdWx0aVdvcmRTdWdnZXN0 |
| aW9uQ2FuZGlkYXRlLnRleHQifX0sIHsiZW5kIjogMTUwMTIsICJiZWdpbiI6IDE0OTk2LCAiZWRn |
| ZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAi |
| dm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3Ny |
| YyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY2hyb21lb3MubWFjaGluZV9s |
| ZWFybmluZy5tb2pvbS5NdWx0aVdvcmRTdWdnZXN0aW9uQ2FuZGlkYXRlLm5vcm1hbGl6ZWRfc2Nv |
| cmUifX0sIHsiZW5kIjogMTYxNzEsICJiZWdpbiI6IDE2MTU0LCAiZWRnZSI6ICIlL2t5dGhlL2Vk |
| Z2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1 |
| cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6 |
| ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY2hyb21lb3MubWFjaGluZV9sZWFybmluZy5tb2pvbS5U |
| ZXh0U3VnZ2VzdGVyU3BlYyJ9fSwgeyJlbmQiOiAyMDAyMywgImJlZ2luIjogMjAwMDIsICJlZGdl |
| IjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2 |
| bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3Jj |
| IiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJjaHJvbWVvcy5tYWNoaW5lX2xl |
| YXJuaW5nLm1vam9tLlRleHRTdWdnZXN0ZXJTcGVjLm11bHRpX3dvcmRfZXhwZXJpbWVudCJ9fSwg |
| eyJlbmQiOiAyMTE0OSwgImJlZ2luIjogMjExMjYsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5l |
| cmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNo |
| cm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9t |
| IiwgInNpZ25hdHVyZSI6ICJjaHJvbWVvcy5tYWNoaW5lX2xlYXJuaW5nLm1vam9tLlRleHRTdWdn |
| ZXN0aW9uQ2FuZGlkYXRlIn19LCB7ImVuZCI6IDIzNDM0LCAiYmVnaW4iOiAyMzQyMSwgImVkZ2Ui |
| OiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZu |
| YW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMi |
| LCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImNocm9tZW9zLm1hY2hpbmVfbGVh |
| cm5pbmcubW9qb20uVGV4dFN1Z2dlc3Rpb25DYW5kaWRhdGUubXVsdGlfd29yZCJ9fSwgeyJlbmQi |
| OiAyMzYxOSwgImJlZ2luIjogMjM2MDUsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMi |
| LCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVt |
| Lmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNp |
| Z25hdHVyZSI6ICJjaHJvbWVvcy5tYWNoaW5lX2xlYXJuaW5nLm1vam9tLlRleHRTdWdnZXN0aW9u |
| Q2FuZGlkYXRlLm11bHRpX3dvcmQifX0sIHsiZW5kIjogMjM4MTQsICJiZWdpbiI6IDIzODAwLCAi |
| ZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMi |
| LCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVt |
| L3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY2hyb21lb3MubWFjaGlu |
| ZV9sZWFybmluZy5tb2pvbS5UZXh0U3VnZ2VzdGlvbkNhbmRpZGF0ZS5tdWx0aV93b3JkIn19LCB7 |
| ImVuZCI6IDI0ODE3LCAiYmVnaW4iOiAyNDc5OSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVy |
| YXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hy |
| b21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20i |
| LCAic2lnbmF0dXJlIjogImNocm9tZW9zLm1hY2hpbmVfbGVhcm5pbmcubW9qb20uVGV4dFN1Z2dl |
| c3RlclF1ZXJ5In19LCB7ImVuZCI6IDI4OTQ1LCAiYmVnaW4iOiAyODk0MSwgImVkZ2UiOiAiJS9r |
| eXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjog |
| eyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFu |
| Z3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImNocm9tZW9zLm1hY2hpbmVfbGVhcm5pbmcu |
| bW9qb20uVGV4dFN1Z2dlc3RlclF1ZXJ5LnRleHQifX0sIHsiZW5kIjogMjkxMDgsICJiZWdpbiI6 |
| IDI5MDg4LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9y |
| X2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29t |
| L2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY2hyb21l |
| b3MubWFjaGluZV9sZWFybmluZy5tb2pvbS5UZXh0U3VnZ2VzdGVyUXVlcnkubmV4dF93b3JkX2Nh |
| bmRpZGF0ZXMifX0sIHsiZW5kIjogMjkyMzYsICJiZWdpbiI6IDI5MjIxLCAiZWRnZSI6ICIlL2t5 |
| dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7 |
| ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5n |
| dWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY2hyb21lb3MubWFjaGluZV9sZWFybmluZy5t |
| b2pvbS5UZXh0U3VnZ2VzdGVyUXVlcnkuc3VnZ2VzdGlvbl9tb2RlIn19LCB7ImVuZCI6IDMwMzU5 |
| LCAiYmVnaW4iOiAzMDM0MCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBl |
| IjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xl |
| c291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJl |
| IjogImNocm9tZW9zLm1hY2hpbmVfbGVhcm5pbmcubW9qb20uVGV4dFN1Z2dlc3RlclJlc3VsdCJ9 |
| fSwgeyJlbmQiOiAzMDY3NCwgImJlZ2luIjogMzA2NjgsICJlZGdlIjogIiUva3l0aGUvZWRnZS9n |
| ZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjog |
| ImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1v |
| am9tIiwgInNpZ25hdHVyZSI6ICJjaHJvbWVvcy5tYWNoaW5lX2xlYXJuaW5nLm1vam9tLlRleHRT |
| dWdnZXN0ZXJSZXN1bHQuU3RhdHVzIn19LCB7ImVuZCI6IDM0NDgxLCAiYmVnaW4iOiAzNDQ3NSwg |
| ImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVz |
| IiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1 |
| bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImNocm9tZW9zLm1hY2hp |
| bmVfbGVhcm5pbmcubW9qb20uVGV4dFN1Z2dlc3RlclJlc3VsdC5zdGF0dXMifX0sIHsiZW5kIjog |
| MzQ2MjgsICJiZWdpbiI6IDM0NjE4LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwg |
| InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5n |
| b29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWdu |
| YXR1cmUiOiAiY2hyb21lb3MubWFjaGluZV9sZWFybmluZy5tb2pvbS5UZXh0U3VnZ2VzdGVyUmVz |
| dWx0LmNhbmRpZGF0ZXMifX1dLCAidHlwZSI6ICJreXRoZTAifQ== |
| */ |