| // chromeos/services/machine_learning/public/mojom/web_platform_handwriting.mojom-blink.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_WEB_PLATFORM_HANDWRITING_MOJOM_BLINK_H_ |
| #define CHROMEOS_SERVICES_MACHINE_LEARNING_PUBLIC_MOJOM_WEB_PLATFORM_HANDWRITING_MOJOM_BLINK_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/web_platform_handwriting.mojom-shared.h" |
| #include "chromeos/services/machine_learning/public/mojom/web_platform_handwriting.mojom-blink-forward.h" |
| #include "mojo/public/mojom/base/time.mojom-blink.h" |
| #include "ui/gfx/geometry/mojom/geometry.mojom-blink.h" |
| |
| #include "mojo/public/cpp/bindings/lib/wtf_clone_equals_util.h" |
| #include "mojo/public/cpp/bindings/lib/wtf_hash_util.h" |
| #include "third_party/blink/renderer/platform/wtf/hash_functions.h" |
| #include "third_party/blink/renderer/platform/wtf/text/wtf_string.h" |
| |
| #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 web_platform { |
| namespace mojom { |
| namespace blink { |
| |
| class HandwritingRecognizerProxy; |
| |
| template <typename ImplRefTraits> |
| class HandwritingRecognizerStub; |
| |
| class HandwritingRecognizerRequestValidator; |
| class HandwritingRecognizerResponseValidator; |
| |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingRecognizer |
| class COMPONENT_EXPORT(MLSERVICE_MOJOM_BLINK) HandwritingRecognizer |
| : public HandwritingRecognizerInterfaceBase { |
| 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_ = HandwritingRecognizerInterfaceBase; |
| using Proxy_ = HandwritingRecognizerProxy; |
| |
| template <typename ImplRefTraits> |
| using Stub_ = HandwritingRecognizerStub<ImplRefTraits>; |
| |
| using RequestValidator_ = HandwritingRecognizerRequestValidator; |
| using ResponseValidator_ = HandwritingRecognizerResponseValidator; |
| enum MethodMinVersions : uint32_t { |
| kGetPredictionMinVersion = 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 GetPrediction_Sym { |
| NOINLINE static void IPCSymbol(); |
| }; |
| #endif // !BUILDFLAG(IS_FUCHSIA) |
| virtual ~HandwritingRecognizer() = default; |
| |
| |
| using GetPredictionCallback = base::OnceCallback<void(absl::optional<WTF::Vector<HandwritingPredictionPtr>>)>; |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingRecognizer.GetPrediction |
| virtual void GetPrediction(WTF::Vector<HandwritingStrokePtr> strokes, HandwritingHintsPtr hints, GetPredictionCallback callback) = 0; |
| }; |
| |
| |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingRecognizer |
| class COMPONENT_EXPORT(MLSERVICE_MOJOM_BLINK) HandwritingRecognizerProxy |
| : public HandwritingRecognizer { |
| public: |
| using InterfaceType = HandwritingRecognizer; |
| |
| explicit HandwritingRecognizerProxy(mojo::MessageReceiverWithResponder* receiver); |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingRecognizer.GetPrediction |
| void GetPrediction(WTF::Vector<HandwritingStrokePtr> strokes, HandwritingHintsPtr hints, GetPredictionCallback callback) final; |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| class COMPONENT_EXPORT(MLSERVICE_MOJOM_BLINK) HandwritingRecognizerStubDispatch { |
| public: |
| static bool Accept(HandwritingRecognizer* impl, mojo::Message* message); |
| static bool AcceptWithResponder( |
| HandwritingRecognizer* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder); |
| }; |
| |
| template <typename ImplRefTraits = |
| mojo::RawPtrImplRefTraits<HandwritingRecognizer>> |
| class HandwritingRecognizerStub |
| : public mojo::MessageReceiverWithResponderStatus { |
| public: |
| using ImplPointerType = typename ImplRefTraits::PointerType; |
| |
| HandwritingRecognizerStub() = default; |
| ~HandwritingRecognizerStub() 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 HandwritingRecognizerStubDispatch::Accept( |
| ImplRefTraits::GetRawPointer(&sink_), message); |
| } |
| |
| bool AcceptWithResponder( |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return HandwritingRecognizerStubDispatch::AcceptWithResponder( |
| ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); |
| } |
| |
| private: |
| ImplPointerType sink_; |
| }; |
| class COMPONENT_EXPORT(MLSERVICE_MOJOM_BLINK) HandwritingRecognizerRequestValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class COMPONENT_EXPORT(MLSERVICE_MOJOM_BLINK) HandwritingRecognizerResponseValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| |
| |
| |
| |
| |
| |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingDrawingSegment |
| class COMPONENT_EXPORT(MLSERVICE_MOJOM_BLINK) HandwritingDrawingSegment { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<HandwritingDrawingSegment, T>::value>; |
| using DataView = HandwritingDrawingSegmentDataView; |
| using Data_ = internal::HandwritingDrawingSegment_Data; |
| |
| template <typename... Args> |
| static HandwritingDrawingSegmentPtr New(Args&&... args) { |
| return HandwritingDrawingSegmentPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static HandwritingDrawingSegmentPtr From(const U& u) { |
| return mojo::TypeConverter<HandwritingDrawingSegmentPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, HandwritingDrawingSegment>::Convert(*this); |
| } |
| |
| |
| HandwritingDrawingSegment(); |
| |
| HandwritingDrawingSegment( |
| uint32_t stroke_index, |
| uint32_t begin_point_index, |
| uint32_t end_point_index); |
| |
| |
| ~HandwritingDrawingSegment(); |
| |
| // 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 = HandwritingDrawingSegmentPtr> |
| HandwritingDrawingSegmentPtr 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, HandwritingDrawingSegment::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, HandwritingDrawingSegment::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| size_t Hash(size_t seed) const; |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| HandwritingDrawingSegment::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| HandwritingDrawingSegment::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::HandwritingDrawingSegment_UnserializedMessageContext< |
| UserType, HandwritingDrawingSegment::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<HandwritingDrawingSegment::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return HandwritingDrawingSegment::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::HandwritingDrawingSegment_UnserializedMessageContext< |
| UserType, HandwritingDrawingSegment::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<HandwritingDrawingSegment::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingDrawingSegment.stroke_index |
| uint32_t stroke_index; |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingDrawingSegment.begin_point_index |
| uint32_t begin_point_index; |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingDrawingSegment.end_point_index |
| uint32_t end_point_index; |
| |
| // 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, HandwritingDrawingSegment::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, HandwritingDrawingSegment::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, HandwritingDrawingSegment::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, HandwritingDrawingSegment::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingPoint |
| class COMPONENT_EXPORT(MLSERVICE_MOJOM_BLINK) HandwritingPoint { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<HandwritingPoint, T>::value>; |
| using DataView = HandwritingPointDataView; |
| using Data_ = internal::HandwritingPoint_Data; |
| |
| template <typename... Args> |
| static HandwritingPointPtr New(Args&&... args) { |
| return HandwritingPointPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static HandwritingPointPtr From(const U& u) { |
| return mojo::TypeConverter<HandwritingPointPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, HandwritingPoint>::Convert(*this); |
| } |
| |
| |
| HandwritingPoint(); |
| |
| HandwritingPoint( |
| const ::gfx::PointF& location, |
| absl::optional<::base::TimeDelta> t); |
| |
| |
| ~HandwritingPoint(); |
| |
| // 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 = HandwritingPointPtr> |
| HandwritingPointPtr 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, HandwritingPoint::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, HandwritingPoint::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| HandwritingPoint::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| HandwritingPoint::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::HandwritingPoint_UnserializedMessageContext< |
| UserType, HandwritingPoint::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<HandwritingPoint::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return HandwritingPoint::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::HandwritingPoint_UnserializedMessageContext< |
| UserType, HandwritingPoint::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<HandwritingPoint::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingPoint.location |
| ::gfx::PointF location; |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingPoint.t |
| absl::optional<::base::TimeDelta> t; |
| |
| // 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, HandwritingPoint::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, HandwritingPoint::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, HandwritingPoint::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, HandwritingPoint::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingStroke |
| class COMPONENT_EXPORT(MLSERVICE_MOJOM_BLINK) HandwritingStroke { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<HandwritingStroke, T>::value>; |
| using DataView = HandwritingStrokeDataView; |
| using Data_ = internal::HandwritingStroke_Data; |
| |
| template <typename... Args> |
| static HandwritingStrokePtr New(Args&&... args) { |
| return HandwritingStrokePtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static HandwritingStrokePtr From(const U& u) { |
| return mojo::TypeConverter<HandwritingStrokePtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, HandwritingStroke>::Convert(*this); |
| } |
| |
| |
| HandwritingStroke(); |
| |
| explicit HandwritingStroke( |
| WTF::Vector<HandwritingPointPtr> points); |
| |
| HandwritingStroke(const HandwritingStroke&) = delete; |
| HandwritingStroke& operator=(const HandwritingStroke&) = delete; |
| |
| ~HandwritingStroke(); |
| |
| // 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 = HandwritingStrokePtr> |
| HandwritingStrokePtr 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, HandwritingStroke::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, HandwritingStroke::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| HandwritingStroke::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| HandwritingStroke::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::HandwritingStroke_UnserializedMessageContext< |
| UserType, HandwritingStroke::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<HandwritingStroke::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return HandwritingStroke::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::HandwritingStroke_UnserializedMessageContext< |
| UserType, HandwritingStroke::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<HandwritingStroke::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingStroke.points |
| WTF::Vector<HandwritingPointPtr> points; |
| |
| // 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, HandwritingStroke::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, HandwritingStroke::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, HandwritingStroke::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, HandwritingStroke::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingSegment |
| class COMPONENT_EXPORT(MLSERVICE_MOJOM_BLINK) HandwritingSegment { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<HandwritingSegment, T>::value>; |
| using DataView = HandwritingSegmentDataView; |
| using Data_ = internal::HandwritingSegment_Data; |
| |
| template <typename... Args> |
| static HandwritingSegmentPtr New(Args&&... args) { |
| return HandwritingSegmentPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static HandwritingSegmentPtr From(const U& u) { |
| return mojo::TypeConverter<HandwritingSegmentPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, HandwritingSegment>::Convert(*this); |
| } |
| |
| |
| HandwritingSegment(); |
| |
| HandwritingSegment( |
| const WTF::String& grapheme, |
| uint32_t begin_index, |
| uint32_t end_index, |
| WTF::Vector<HandwritingDrawingSegmentPtr> drawing_segments); |
| |
| HandwritingSegment(const HandwritingSegment&) = delete; |
| HandwritingSegment& operator=(const HandwritingSegment&) = delete; |
| |
| ~HandwritingSegment(); |
| |
| // 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 = HandwritingSegmentPtr> |
| HandwritingSegmentPtr 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, HandwritingSegment::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, HandwritingSegment::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| HandwritingSegment::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| HandwritingSegment::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::HandwritingSegment_UnserializedMessageContext< |
| UserType, HandwritingSegment::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<HandwritingSegment::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return HandwritingSegment::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::HandwritingSegment_UnserializedMessageContext< |
| UserType, HandwritingSegment::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<HandwritingSegment::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingSegment.grapheme |
| WTF::String grapheme; |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingSegment.begin_index |
| uint32_t begin_index; |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingSegment.end_index |
| uint32_t end_index; |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingSegment.drawing_segments |
| WTF::Vector<HandwritingDrawingSegmentPtr> drawing_segments; |
| |
| // 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, HandwritingSegment::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, HandwritingSegment::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, HandwritingSegment::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, HandwritingSegment::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingPrediction |
| class COMPONENT_EXPORT(MLSERVICE_MOJOM_BLINK) HandwritingPrediction { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<HandwritingPrediction, T>::value>; |
| using DataView = HandwritingPredictionDataView; |
| using Data_ = internal::HandwritingPrediction_Data; |
| |
| template <typename... Args> |
| static HandwritingPredictionPtr New(Args&&... args) { |
| return HandwritingPredictionPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static HandwritingPredictionPtr From(const U& u) { |
| return mojo::TypeConverter<HandwritingPredictionPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, HandwritingPrediction>::Convert(*this); |
| } |
| |
| |
| HandwritingPrediction(); |
| |
| HandwritingPrediction( |
| const WTF::String& text, |
| WTF::Vector<HandwritingSegmentPtr> segmentation_result); |
| |
| HandwritingPrediction(const HandwritingPrediction&) = delete; |
| HandwritingPrediction& operator=(const HandwritingPrediction&) = delete; |
| |
| ~HandwritingPrediction(); |
| |
| // 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 = HandwritingPredictionPtr> |
| HandwritingPredictionPtr 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, HandwritingPrediction::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, HandwritingPrediction::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| HandwritingPrediction::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| HandwritingPrediction::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::HandwritingPrediction_UnserializedMessageContext< |
| UserType, HandwritingPrediction::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<HandwritingPrediction::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return HandwritingPrediction::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::HandwritingPrediction_UnserializedMessageContext< |
| UserType, HandwritingPrediction::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<HandwritingPrediction::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingPrediction.text |
| WTF::String text; |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingPrediction.segmentation_result |
| WTF::Vector<HandwritingSegmentPtr> segmentation_result; |
| |
| // 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, HandwritingPrediction::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, HandwritingPrediction::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, HandwritingPrediction::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, HandwritingPrediction::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingHints |
| class COMPONENT_EXPORT(MLSERVICE_MOJOM_BLINK) HandwritingHints { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<HandwritingHints, T>::value>; |
| using DataView = HandwritingHintsDataView; |
| using Data_ = internal::HandwritingHints_Data; |
| |
| template <typename... Args> |
| static HandwritingHintsPtr New(Args&&... args) { |
| return HandwritingHintsPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static HandwritingHintsPtr From(const U& u) { |
| return mojo::TypeConverter<HandwritingHintsPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, HandwritingHints>::Convert(*this); |
| } |
| |
| |
| HandwritingHints(); |
| |
| HandwritingHints( |
| const WTF::String& recognition_type, |
| const WTF::String& input_type, |
| const WTF::String& deprecated_text_context, |
| uint32_t alternatives); |
| |
| HandwritingHints( |
| const WTF::String& recognition_type, |
| const WTF::String& input_type, |
| const WTF::String& deprecated_text_context, |
| uint32_t alternatives, |
| const WTF::String& text_context); |
| |
| |
| ~HandwritingHints(); |
| |
| // 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 = HandwritingHintsPtr> |
| HandwritingHintsPtr 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, HandwritingHints::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, HandwritingHints::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| HandwritingHints::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| HandwritingHints::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::HandwritingHints_UnserializedMessageContext< |
| UserType, HandwritingHints::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<HandwritingHints::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return HandwritingHints::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::HandwritingHints_UnserializedMessageContext< |
| UserType, HandwritingHints::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<HandwritingHints::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingHints.recognition_type |
| WTF::String recognition_type; |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingHints.input_type |
| WTF::String input_type; |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingHints.deprecated_text_context |
| WTF::String deprecated_text_context; |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingHints.alternatives |
| uint32_t alternatives; |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingHints.text_context |
| WTF::String text_context; |
| |
| // 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, HandwritingHints::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, HandwritingHints::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, HandwritingHints::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, HandwritingHints::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingModelConstraint |
| class COMPONENT_EXPORT(MLSERVICE_MOJOM_BLINK) HandwritingModelConstraint { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<HandwritingModelConstraint, T>::value>; |
| using DataView = HandwritingModelConstraintDataView; |
| using Data_ = internal::HandwritingModelConstraint_Data; |
| |
| template <typename... Args> |
| static HandwritingModelConstraintPtr New(Args&&... args) { |
| return HandwritingModelConstraintPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static HandwritingModelConstraintPtr From(const U& u) { |
| return mojo::TypeConverter<HandwritingModelConstraintPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, HandwritingModelConstraint>::Convert(*this); |
| } |
| |
| |
| HandwritingModelConstraint(); |
| |
| explicit HandwritingModelConstraint( |
| WTF::Vector<WTF::String> languages); |
| |
| |
| ~HandwritingModelConstraint(); |
| |
| // 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 = HandwritingModelConstraintPtr> |
| HandwritingModelConstraintPtr 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, HandwritingModelConstraint::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, HandwritingModelConstraint::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| HandwritingModelConstraint::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| HandwritingModelConstraint::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::HandwritingModelConstraint_UnserializedMessageContext< |
| UserType, HandwritingModelConstraint::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<HandwritingModelConstraint::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return HandwritingModelConstraint::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::HandwritingModelConstraint_UnserializedMessageContext< |
| UserType, HandwritingModelConstraint::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<HandwritingModelConstraint::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: chromeos.machine_learning.web_platform.mojom.HandwritingModelConstraint.languages |
| WTF::Vector<WTF::String> languages; |
| |
| // 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, HandwritingModelConstraint::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, HandwritingModelConstraint::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, HandwritingModelConstraint::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, HandwritingModelConstraint::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| template <typename StructPtrType> |
| HandwritingPointPtr HandwritingPoint::Clone() const { |
| return New( |
| mojo::Clone(location), |
| mojo::Clone(t) |
| ); |
| } |
| |
| template <typename T, HandwritingPoint::EnableIfSame<T>*> |
| bool HandwritingPoint::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->location, other_struct.location)) |
| return false; |
| if (!mojo::Equals(this->t, other_struct.t)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, HandwritingPoint::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.location < rhs.location) |
| return true; |
| if (rhs.location < lhs.location) |
| return false; |
| if (lhs.t < rhs.t) |
| return true; |
| if (rhs.t < lhs.t) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| HandwritingStrokePtr HandwritingStroke::Clone() const { |
| return New( |
| mojo::Clone(points) |
| ); |
| } |
| |
| template <typename T, HandwritingStroke::EnableIfSame<T>*> |
| bool HandwritingStroke::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->points, other_struct.points)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, HandwritingStroke::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.points < rhs.points) |
| return true; |
| if (rhs.points < lhs.points) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| HandwritingDrawingSegmentPtr HandwritingDrawingSegment::Clone() const { |
| return New( |
| mojo::Clone(stroke_index), |
| mojo::Clone(begin_point_index), |
| mojo::Clone(end_point_index) |
| ); |
| } |
| |
| template <typename T, HandwritingDrawingSegment::EnableIfSame<T>*> |
| bool HandwritingDrawingSegment::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->stroke_index, other_struct.stroke_index)) |
| return false; |
| if (!mojo::Equals(this->begin_point_index, other_struct.begin_point_index)) |
| return false; |
| if (!mojo::Equals(this->end_point_index, other_struct.end_point_index)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, HandwritingDrawingSegment::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.stroke_index < rhs.stroke_index) |
| return true; |
| if (rhs.stroke_index < lhs.stroke_index) |
| return false; |
| if (lhs.begin_point_index < rhs.begin_point_index) |
| return true; |
| if (rhs.begin_point_index < lhs.begin_point_index) |
| return false; |
| if (lhs.end_point_index < rhs.end_point_index) |
| return true; |
| if (rhs.end_point_index < lhs.end_point_index) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| HandwritingSegmentPtr HandwritingSegment::Clone() const { |
| return New( |
| mojo::Clone(grapheme), |
| mojo::Clone(begin_index), |
| mojo::Clone(end_index), |
| mojo::Clone(drawing_segments) |
| ); |
| } |
| |
| template <typename T, HandwritingSegment::EnableIfSame<T>*> |
| bool HandwritingSegment::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->grapheme, other_struct.grapheme)) |
| return false; |
| if (!mojo::Equals(this->begin_index, other_struct.begin_index)) |
| return false; |
| if (!mojo::Equals(this->end_index, other_struct.end_index)) |
| return false; |
| if (!mojo::Equals(this->drawing_segments, other_struct.drawing_segments)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, HandwritingSegment::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.grapheme < rhs.grapheme) |
| return true; |
| if (rhs.grapheme < lhs.grapheme) |
| return false; |
| if (lhs.begin_index < rhs.begin_index) |
| return true; |
| if (rhs.begin_index < lhs.begin_index) |
| return false; |
| if (lhs.end_index < rhs.end_index) |
| return true; |
| if (rhs.end_index < lhs.end_index) |
| return false; |
| if (lhs.drawing_segments < rhs.drawing_segments) |
| return true; |
| if (rhs.drawing_segments < lhs.drawing_segments) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| HandwritingPredictionPtr HandwritingPrediction::Clone() const { |
| return New( |
| mojo::Clone(text), |
| mojo::Clone(segmentation_result) |
| ); |
| } |
| |
| template <typename T, HandwritingPrediction::EnableIfSame<T>*> |
| bool HandwritingPrediction::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->text, other_struct.text)) |
| return false; |
| if (!mojo::Equals(this->segmentation_result, other_struct.segmentation_result)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, HandwritingPrediction::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.segmentation_result < rhs.segmentation_result) |
| return true; |
| if (rhs.segmentation_result < lhs.segmentation_result) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| HandwritingHintsPtr HandwritingHints::Clone() const { |
| return New( |
| mojo::Clone(recognition_type), |
| mojo::Clone(input_type), |
| mojo::Clone(deprecated_text_context), |
| mojo::Clone(alternatives), |
| mojo::Clone(text_context) |
| ); |
| } |
| |
| template <typename T, HandwritingHints::EnableIfSame<T>*> |
| bool HandwritingHints::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->recognition_type, other_struct.recognition_type)) |
| return false; |
| if (!mojo::Equals(this->input_type, other_struct.input_type)) |
| return false; |
| if (!mojo::Equals(this->deprecated_text_context, other_struct.deprecated_text_context)) |
| return false; |
| if (!mojo::Equals(this->alternatives, other_struct.alternatives)) |
| return false; |
| if (!mojo::Equals(this->text_context, other_struct.text_context)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, HandwritingHints::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.recognition_type < rhs.recognition_type) |
| return true; |
| if (rhs.recognition_type < lhs.recognition_type) |
| return false; |
| if (lhs.input_type < rhs.input_type) |
| return true; |
| if (rhs.input_type < lhs.input_type) |
| return false; |
| if (lhs.deprecated_text_context < rhs.deprecated_text_context) |
| return true; |
| if (rhs.deprecated_text_context < lhs.deprecated_text_context) |
| return false; |
| if (lhs.alternatives < rhs.alternatives) |
| return true; |
| if (rhs.alternatives < lhs.alternatives) |
| return false; |
| if (lhs.text_context < rhs.text_context) |
| return true; |
| if (rhs.text_context < lhs.text_context) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| HandwritingModelConstraintPtr HandwritingModelConstraint::Clone() const { |
| return New( |
| mojo::Clone(languages) |
| ); |
| } |
| |
| template <typename T, HandwritingModelConstraint::EnableIfSame<T>*> |
| bool HandwritingModelConstraint::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->languages, other_struct.languages)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, HandwritingModelConstraint::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.languages < rhs.languages) |
| return true; |
| if (rhs.languages < lhs.languages) |
| return false; |
| return false; |
| } |
| |
| |
| } // namespace blink |
| } // namespace mojom |
| } // namespace web_platform |
| } // namespace machine_learning |
| } // namespace chromeos |
| |
| namespace mojo { |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(MLSERVICE_MOJOM_BLINK) StructTraits<::chromeos::machine_learning::web_platform::mojom::blink::HandwritingPoint::DataView, |
| ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingPointPtr> { |
| static bool IsNull(const ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingPointPtr& input) { return !input; } |
| static void SetToNull(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingPointPtr* output) { output->reset(); } |
| |
| static const decltype(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingPoint::location)& location( |
| const ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingPointPtr& input) { |
| return input->location; |
| } |
| |
| static const decltype(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingPoint::t)& t( |
| const ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingPointPtr& input) { |
| return input->t; |
| } |
| |
| static bool Read(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingPoint::DataView input, ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingPointPtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(MLSERVICE_MOJOM_BLINK) StructTraits<::chromeos::machine_learning::web_platform::mojom::blink::HandwritingStroke::DataView, |
| ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingStrokePtr> { |
| static bool IsNull(const ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingStrokePtr& input) { return !input; } |
| static void SetToNull(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingStrokePtr* output) { output->reset(); } |
| |
| static const decltype(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingStroke::points)& points( |
| const ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingStrokePtr& input) { |
| return input->points; |
| } |
| |
| static bool Read(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingStroke::DataView input, ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingStrokePtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(MLSERVICE_MOJOM_BLINK) StructTraits<::chromeos::machine_learning::web_platform::mojom::blink::HandwritingDrawingSegment::DataView, |
| ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingDrawingSegmentPtr> { |
| static bool IsNull(const ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingDrawingSegmentPtr& input) { return !input; } |
| static void SetToNull(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingDrawingSegmentPtr* output) { output->reset(); } |
| |
| static decltype(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingDrawingSegment::stroke_index) stroke_index( |
| const ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingDrawingSegmentPtr& input) { |
| return input->stroke_index; |
| } |
| |
| static decltype(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingDrawingSegment::begin_point_index) begin_point_index( |
| const ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingDrawingSegmentPtr& input) { |
| return input->begin_point_index; |
| } |
| |
| static decltype(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingDrawingSegment::end_point_index) end_point_index( |
| const ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingDrawingSegmentPtr& input) { |
| return input->end_point_index; |
| } |
| |
| static bool Read(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingDrawingSegment::DataView input, ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingDrawingSegmentPtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(MLSERVICE_MOJOM_BLINK) StructTraits<::chromeos::machine_learning::web_platform::mojom::blink::HandwritingSegment::DataView, |
| ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingSegmentPtr> { |
| static bool IsNull(const ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingSegmentPtr& input) { return !input; } |
| static void SetToNull(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingSegmentPtr* output) { output->reset(); } |
| |
| static const decltype(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingSegment::grapheme)& grapheme( |
| const ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingSegmentPtr& input) { |
| return input->grapheme; |
| } |
| |
| static decltype(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingSegment::begin_index) begin_index( |
| const ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingSegmentPtr& input) { |
| return input->begin_index; |
| } |
| |
| static decltype(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingSegment::end_index) end_index( |
| const ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingSegmentPtr& input) { |
| return input->end_index; |
| } |
| |
| static const decltype(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingSegment::drawing_segments)& drawing_segments( |
| const ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingSegmentPtr& input) { |
| return input->drawing_segments; |
| } |
| |
| static bool Read(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingSegment::DataView input, ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingSegmentPtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(MLSERVICE_MOJOM_BLINK) StructTraits<::chromeos::machine_learning::web_platform::mojom::blink::HandwritingPrediction::DataView, |
| ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingPredictionPtr> { |
| static bool IsNull(const ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingPredictionPtr& input) { return !input; } |
| static void SetToNull(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingPredictionPtr* output) { output->reset(); } |
| |
| static const decltype(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingPrediction::text)& text( |
| const ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingPredictionPtr& input) { |
| return input->text; |
| } |
| |
| static const decltype(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingPrediction::segmentation_result)& segmentation_result( |
| const ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingPredictionPtr& input) { |
| return input->segmentation_result; |
| } |
| |
| static bool Read(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingPrediction::DataView input, ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingPredictionPtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(MLSERVICE_MOJOM_BLINK) StructTraits<::chromeos::machine_learning::web_platform::mojom::blink::HandwritingHints::DataView, |
| ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingHintsPtr> { |
| static bool IsNull(const ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingHintsPtr& input) { return !input; } |
| static void SetToNull(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingHintsPtr* output) { output->reset(); } |
| |
| static const decltype(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingHints::recognition_type)& recognition_type( |
| const ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingHintsPtr& input) { |
| return input->recognition_type; |
| } |
| |
| static const decltype(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingHints::input_type)& input_type( |
| const ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingHintsPtr& input) { |
| return input->input_type; |
| } |
| |
| static const decltype(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingHints::deprecated_text_context)& deprecated_text_context( |
| const ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingHintsPtr& input) { |
| return input->deprecated_text_context; |
| } |
| |
| static decltype(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingHints::alternatives) alternatives( |
| const ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingHintsPtr& input) { |
| return input->alternatives; |
| } |
| |
| static const decltype(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingHints::text_context)& text_context( |
| const ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingHintsPtr& input) { |
| return input->text_context; |
| } |
| |
| static bool Read(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingHints::DataView input, ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingHintsPtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(MLSERVICE_MOJOM_BLINK) StructTraits<::chromeos::machine_learning::web_platform::mojom::blink::HandwritingModelConstraint::DataView, |
| ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingModelConstraintPtr> { |
| static bool IsNull(const ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingModelConstraintPtr& input) { return !input; } |
| static void SetToNull(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingModelConstraintPtr* output) { output->reset(); } |
| |
| static const decltype(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingModelConstraint::languages)& languages( |
| const ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingModelConstraintPtr& input) { |
| return input->languages; |
| } |
| |
| static bool Read(::chromeos::machine_learning::web_platform::mojom::blink::HandwritingModelConstraint::DataView input, ::chromeos::machine_learning::web_platform::mojom::blink::HandwritingModelConstraintPtr* output); |
| }; |
| |
| } // namespace mojo |
| |
| #endif // CHROMEOS_SERVICES_MACHINE_LEARNING_PUBLIC_MOJOM_WEB_PLATFORM_HANDWRITING_MOJOM_BLINK_H_ |
| |
| /* Metadata comment |
| eyJtZXRhIjogW3siZW5kIjogMjMyNiwgImJlZ2luIjogMjMwNSwgImVkZ2UiOiAiJS9reXRoZS9l |
| ZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3Jw |
| dXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2Ui |
| OiAibW9qb20iLCAic2lnbmF0dXJlIjogImNocm9tZW9zLm1hY2hpbmVfbGVhcm5pbmcud2ViX3Bs |
| YXRmb3JtLm1vam9tLkhhbmR3cml0aW5nUmVjb2duaXplciJ9fSwgeyJlbmQiOiAzNzM0LCAiYmVn |
| aW4iOiAzNzIxLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5j |
| aG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2Uu |
| Y29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY2hy |
| b21lb3MubWFjaGluZV9sZWFybmluZy53ZWJfcGxhdGZvcm0ubW9qb20uSGFuZHdyaXRpbmdSZWNv |
| Z25pemVyLkdldFByZWRpY3Rpb24ifX0sIHsiZW5kIjogNDMxMSwgImJlZ2luIjogNDI5OCwgImVk |
| Z2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwg |
| InZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9z |
| cmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImNocm9tZW9zLm1hY2hpbmVf |
| bGVhcm5pbmcud2ViX3BsYXRmb3JtLm1vam9tLkhhbmR3cml0aW5nUmVjb2duaXplci5HZXRQcmVk |
| aWN0aW9uIn19LCB7ImVuZCI6IDY0MTMsICJiZWdpbiI6IDYzODgsICJlZGdlIjogIiUva3l0aGUv |
| ZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29y |
| cHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdl |
| IjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJjaHJvbWVvcy5tYWNoaW5lX2xlYXJuaW5nLndlYl9w |
| bGF0Zm9ybS5tb2pvbS5IYW5kd3JpdGluZ0RyYXdpbmdTZWdtZW50In19LCB7ImVuZCI6IDEwNDc2 |
| LCAiYmVnaW4iOiAxMDQ2NCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBl |
| IjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xl |
| c291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJl |
| IjogImNocm9tZW9zLm1hY2hpbmVfbGVhcm5pbmcud2ViX3BsYXRmb3JtLm1vam9tLkhhbmR3cml0 |
| aW5nRHJhd2luZ1NlZ21lbnQuc3Ryb2tlX2luZGV4In19LCB7ImVuZCI6IDEwNjE4LCAiYmVnaW4i |
| OiAxMDYwMSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hv |
| cl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNv |
| bS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImNocm9t |
| ZW9zLm1hY2hpbmVfbGVhcm5pbmcud2ViX3BsYXRmb3JtLm1vam9tLkhhbmR3cml0aW5nRHJhd2lu |
| Z1NlZ21lbnQuYmVnaW5fcG9pbnRfaW5kZXgifX0sIHsiZW5kIjogMTA3NTYsICJiZWdpbiI6IDEw |
| NzQxLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2Rl |
| ZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2No |
| cm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY2hyb21lb3Mu |
| bWFjaGluZV9sZWFybmluZy53ZWJfcGxhdGZvcm0ubW9qb20uSGFuZHdyaXRpbmdEcmF3aW5nU2Vn |
| bWVudC5lbmRfcG9pbnRfaW5kZXgifX0sIHsiZW5kIjogMTE5MjUsICJiZWdpbiI6IDExOTA5LCAi |
| ZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMi |
| LCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVt |
| L3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY2hyb21lb3MubWFjaGlu |
| ZV9sZWFybmluZy53ZWJfcGxhdGZvcm0ubW9qb20uSGFuZHdyaXRpbmdQb2ludCJ9fSwgeyJlbmQi |
| OiAxNTcxMSwgImJlZ2luIjogMTU3MDMsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMi |
| LCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVt |
| Lmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNp |
| Z25hdHVyZSI6ICJjaHJvbWVvcy5tYWNoaW5lX2xlYXJuaW5nLndlYl9wbGF0Zm9ybS5tb2pvbS5I |
| YW5kd3JpdGluZ1BvaW50LmxvY2F0aW9uIn19LCB7ImVuZCI6IDE1ODM3LCAiYmVnaW4iOiAxNTgz |
| NiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZp |
| bmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJv |
| bWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImNocm9tZW9zLm1h |
| Y2hpbmVfbGVhcm5pbmcud2ViX3BsYXRmb3JtLm1vam9tLkhhbmR3cml0aW5nUG9pbnQudCJ9fSwg |
| eyJlbmQiOiAxNjk2NiwgImJlZ2luIjogMTY5NDksICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5l |
| cmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNo |
| cm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9t |
| IiwgInNpZ25hdHVyZSI6ICJjaHJvbWVvcy5tYWNoaW5lX2xlYXJuaW5nLndlYl9wbGF0Zm9ybS5t |
| b2pvbS5IYW5kd3JpdGluZ1N0cm9rZSJ9fSwgeyJlbmQiOiAyMDg4NywgImJlZ2luIjogMjA4ODEs |
| ICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5l |
| cyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21p |
| dW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJjaHJvbWVvcy5tYWNo |
| aW5lX2xlYXJuaW5nLndlYl9wbGF0Zm9ybS5tb2pvbS5IYW5kd3JpdGluZ1N0cm9rZS5wb2ludHMi |
| fX0sIHsiZW5kIjogMjIwMjMsICJiZWdpbiI6IDIyMDA1LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2Uv |
| Z2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6 |
| ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJt |
| b2pvbSIsICJzaWduYXR1cmUiOiAiY2hyb21lb3MubWFjaGluZV9sZWFybmluZy53ZWJfcGxhdGZv |
| cm0ubW9qb20uSGFuZHdyaXRpbmdTZWdtZW50In19LCB7ImVuZCI6IDI2MDU1LCAiYmVnaW4iOiAy |
| NjA0NywgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9k |
| ZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9j |
| aHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImNocm9tZW9z |
| Lm1hY2hpbmVfbGVhcm5pbmcud2ViX3BsYXRmb3JtLm1vam9tLkhhbmR3cml0aW5nU2VnbWVudC5n |
| cmFwaGVtZSJ9fSwgeyJlbmQiOiAyNjE3OCwgImJlZ2luIjogMjYxNjcsICJlZGdlIjogIiUva3l0 |
| aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsi |
| Y29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1 |
| YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJjaHJvbWVvcy5tYWNoaW5lX2xlYXJuaW5nLndl |
| Yl9wbGF0Zm9ybS5tb2pvbS5IYW5kd3JpdGluZ1NlZ21lbnQuYmVnaW5faW5kZXgifX0sIHsiZW5k |
| IjogMjYyOTcsICJiZWdpbiI6IDI2Mjg4LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVz |
| IiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1 |
| bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJz |
| aWduYXR1cmUiOiAiY2hyb21lb3MubWFjaGluZV9sZWFybmluZy53ZWJfcGxhdGZvcm0ubW9qb20u |
| SGFuZHdyaXRpbmdTZWdtZW50LmVuZF9pbmRleCJ9fSwgeyJlbmQiOiAyNjQ2MywgImJlZ2luIjog |
| MjY0NDcsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3Jf |
| ZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20v |
| Y2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJjaHJvbWVv |
| cy5tYWNoaW5lX2xlYXJuaW5nLndlYl9wbGF0Zm9ybS5tb2pvbS5IYW5kd3JpdGluZ1NlZ21lbnQu |
| ZHJhd2luZ19zZWdtZW50cyJ9fSwgeyJlbmQiOiAyNzYwOCwgImJlZ2luIjogMjc1ODcsICJlZGdl |
| IjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2 |
| bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3Jj |
| IiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJjaHJvbWVvcy5tYWNoaW5lX2xl |
| YXJuaW5nLndlYl9wbGF0Zm9ybS5tb2pvbS5IYW5kd3JpdGluZ1ByZWRpY3Rpb24ifX0sIHsiZW5k |
| IjogMzE2NTcsICJiZWdpbiI6IDMxNjUzLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVz |
| IiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1 |
| bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJz |
| aWduYXR1cmUiOiAiY2hyb21lb3MubWFjaGluZV9sZWFybmluZy53ZWJfcGxhdGZvcm0ubW9qb20u |
| SGFuZHdyaXRpbmdQcmVkaWN0aW9uLnRleHQifX0sIHsiZW5kIjogMzE4MjUsICJiZWdpbiI6IDMx |
| ODA2LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2Rl |
| ZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2No |
| cm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY2hyb21lb3Mu |
| bWFjaGluZV9sZWFybmluZy53ZWJfcGxhdGZvcm0ubW9qb20uSGFuZHdyaXRpbmdQcmVkaWN0aW9u |
| LnNlZ21lbnRhdGlvbl9yZXN1bHQifX0sIHsiZW5kIjogMzI5NzIsICJiZWdpbiI6IDMyOTU2LCAi |
| ZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMi |
| LCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVt |
| L3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY2hyb21lb3MubWFjaGlu |
| ZV9sZWFybmluZy53ZWJfcGxhdGZvcm0ubW9qb20uSGFuZHdyaXRpbmdIaW50cyJ9fSwgeyJlbmQi |
| OiAzNzA3MSwgImJlZ2luIjogMzcwNTUsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMi |
| LCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVt |
| Lmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNp |
| Z25hdHVyZSI6ICJjaHJvbWVvcy5tYWNoaW5lX2xlYXJuaW5nLndlYl9wbGF0Zm9ybS5tb2pvbS5I |
| YW5kd3JpdGluZ0hpbnRzLnJlY29nbml0aW9uX3R5cGUifX0sIHsiZW5kIjogMzcxOTMsICJiZWdp |
| biI6IDM3MTgzLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5j |
| aG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2Uu |
| Y29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY2hy |
| b21lb3MubWFjaGluZV9sZWFybmluZy53ZWJfcGxhdGZvcm0ubW9qb20uSGFuZHdyaXRpbmdIaW50 |
| cy5pbnB1dF90eXBlIn19LCB7ImVuZCI6IDM3MzQxLCAiYmVnaW4iOiAzNzMxOCwgImVkZ2UiOiAi |
| JS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1l |
| IjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAi |
| bGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImNocm9tZW9zLm1hY2hpbmVfbGVhcm5p |
| bmcud2ViX3BsYXRmb3JtLm1vam9tLkhhbmR3cml0aW5nSGludHMuZGVwcmVjYXRlZF90ZXh0X2Nv |
| bnRleHQifX0sIHsiZW5kIjogMzc0NjQsICJiZWdpbiI6IDM3NDUyLCAiZWRnZSI6ICIlL2t5dGhl |
| L2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNv |
| cnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFn |
| ZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY2hyb21lb3MubWFjaGluZV9sZWFybmluZy53ZWJf |
| cGxhdGZvcm0ubW9qb20uSGFuZHdyaXRpbmdIaW50cy5hbHRlcm5hdGl2ZXMifX0sIHsiZW5kIjog |
| Mzc1OTAsICJiZWdpbiI6IDM3NTc4LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwg |
| InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5n |
| b29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWdu |
| YXR1cmUiOiAiY2hyb21lb3MubWFjaGluZV9sZWFybmluZy53ZWJfcGxhdGZvcm0ubW9qb20uSGFu |
| ZHdyaXRpbmdIaW50cy50ZXh0X2NvbnRleHQifX0sIHsiZW5kIjogMzg3MzcsICJiZWdpbiI6IDM4 |
| NzExLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2Rl |
| ZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2No |
| cm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY2hyb21lb3Mu |
| bWFjaGluZV9sZWFybmluZy53ZWJfcGxhdGZvcm0ubW9qb20uSGFuZHdyaXRpbmdNb2RlbENvbnN0 |
| cmFpbnQifX0sIHsiZW5kIjogNDI3NTcsICJiZWdpbiI6IDQyNzQ4LCAiZWRnZSI6ICIlL2t5dGhl |
| L2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNv |
| cnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFn |
| ZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY2hyb21lb3MubWFjaGluZV9sZWFybmluZy53ZWJf |
| cGxhdGZvcm0ubW9qb20uSGFuZHdyaXRpbmdNb2RlbENvbnN0cmFpbnQubGFuZ3VhZ2VzIn19XSwg |
| InR5cGUiOiAia3l0aGUwIn0= |
| */ |