| // 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 SERVICES_DEVICE_PUBLIC_MOJOM_NFC_MOJOM_BLINK_H_ |
| #define SERVICES_DEVICE_PUBLIC_MOJOM_NFC_MOJOM_BLINK_H_ |
| |
| #include <stdint.h> |
| |
| #include <limits> |
| #include <type_traits> |
| #include <utility> |
| |
| #include "base/callback.h" |
| #include "base/macros.h" |
| #include "base/optional.h" |
| |
| #include "mojo/public/cpp/bindings/mojo_buildflags.h" |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| #include "base/trace_event/trace_event.h" |
| #endif |
| #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 "services/device/public/mojom/nfc.mojom-shared.h" |
| #include "services/device/public/mojom/nfc.mojom-blink-forward.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/associated_interface_ptr.h" |
| #include "mojo/public/cpp/bindings/associated_interface_ptr_info.h" |
| #include "mojo/public/cpp/bindings/associated_interface_request.h" |
| #include "mojo/public/cpp/bindings/interface_ptr.h" |
| #include "mojo/public/cpp/bindings/interface_request.h" |
| #include "mojo/public/cpp/bindings/lib/control_message_handler.h" |
| #include "mojo/public/cpp/bindings/raw_ptr_impl_ref_traits.h" |
| #include "mojo/public/cpp/bindings/thread_safe_interface_ptr.h" |
| |
| |
| #include "mojo/public/cpp/bindings/lib/native_enum_serialization.h" |
| #include "mojo/public/cpp/bindings/lib/native_struct_serialization.h" |
| #include "third_party/blink/public/platform/web_common.h" |
| |
| #ifdef KYTHE_IS_RUNNING |
| #pragma kythe_inline_metadata "Metadata comment" |
| #endif |
| |
| |
| namespace WTF { |
| struct device_mojom_internal_NFCErrorType_DataHashFn { |
| static unsigned GetHash(const ::device::mojom::NFCErrorType& value) { |
| using utype = std::underlying_type<::device::mojom::NFCErrorType>::type; |
| return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value)); |
| } |
| static bool Equal(const ::device::mojom::NFCErrorType& left, const ::device::mojom::NFCErrorType& right) { |
| return left == right; |
| } |
| static const bool safe_to_compare_to_empty_or_deleted = true; |
| }; |
| |
| template <> |
| struct HashTraits<::device::mojom::NFCErrorType> |
| : public GenericHashTraits<::device::mojom::NFCErrorType> { |
| static_assert(true, |
| "-1000000 is a reserved enum value"); |
| static_assert(true, |
| "-1000001 is a reserved enum value"); |
| static const bool hasIsEmptyValueFunction = true; |
| static bool IsEmptyValue(const ::device::mojom::NFCErrorType& value) { |
| return value == static_cast<::device::mojom::NFCErrorType>(-1000000); |
| } |
| static void ConstructDeletedValue(::device::mojom::NFCErrorType& slot, bool) { |
| slot = static_cast<::device::mojom::NFCErrorType>(-1000001); |
| } |
| static bool IsDeletedValue(const ::device::mojom::NFCErrorType& value) { |
| return value == static_cast<::device::mojom::NFCErrorType>(-1000001); |
| } |
| }; |
| } // namespace WTF |
| |
| |
| namespace WTF { |
| struct device_mojom_internal_NDEFRecordType_DataHashFn { |
| static unsigned GetHash(const ::device::mojom::NDEFRecordType& value) { |
| using utype = std::underlying_type<::device::mojom::NDEFRecordType>::type; |
| return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value)); |
| } |
| static bool Equal(const ::device::mojom::NDEFRecordType& left, const ::device::mojom::NDEFRecordType& right) { |
| return left == right; |
| } |
| static const bool safe_to_compare_to_empty_or_deleted = true; |
| }; |
| |
| template <> |
| struct HashTraits<::device::mojom::NDEFRecordType> |
| : public GenericHashTraits<::device::mojom::NDEFRecordType> { |
| static_assert(true, |
| "-1000000 is a reserved enum value"); |
| static_assert(true, |
| "-1000001 is a reserved enum value"); |
| static const bool hasIsEmptyValueFunction = true; |
| static bool IsEmptyValue(const ::device::mojom::NDEFRecordType& value) { |
| return value == static_cast<::device::mojom::NDEFRecordType>(-1000000); |
| } |
| static void ConstructDeletedValue(::device::mojom::NDEFRecordType& slot, bool) { |
| slot = static_cast<::device::mojom::NDEFRecordType>(-1000001); |
| } |
| static bool IsDeletedValue(const ::device::mojom::NDEFRecordType& value) { |
| return value == static_cast<::device::mojom::NDEFRecordType>(-1000001); |
| } |
| }; |
| } // namespace WTF |
| |
| |
| namespace WTF { |
| struct device_mojom_internal_NFCPushTarget_DataHashFn { |
| static unsigned GetHash(const ::device::mojom::NFCPushTarget& value) { |
| using utype = std::underlying_type<::device::mojom::NFCPushTarget>::type; |
| return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value)); |
| } |
| static bool Equal(const ::device::mojom::NFCPushTarget& left, const ::device::mojom::NFCPushTarget& right) { |
| return left == right; |
| } |
| static const bool safe_to_compare_to_empty_or_deleted = true; |
| }; |
| |
| template <> |
| struct HashTraits<::device::mojom::NFCPushTarget> |
| : public GenericHashTraits<::device::mojom::NFCPushTarget> { |
| static_assert(true, |
| "-1000000 is a reserved enum value"); |
| static_assert(true, |
| "-1000001 is a reserved enum value"); |
| static const bool hasIsEmptyValueFunction = true; |
| static bool IsEmptyValue(const ::device::mojom::NFCPushTarget& value) { |
| return value == static_cast<::device::mojom::NFCPushTarget>(-1000000); |
| } |
| static void ConstructDeletedValue(::device::mojom::NFCPushTarget& slot, bool) { |
| slot = static_cast<::device::mojom::NFCPushTarget>(-1000001); |
| } |
| static bool IsDeletedValue(const ::device::mojom::NFCPushTarget& value) { |
| return value == static_cast<::device::mojom::NFCPushTarget>(-1000001); |
| } |
| }; |
| } // namespace WTF |
| |
| |
| namespace WTF { |
| struct device_mojom_internal_NDEFCompatibility_DataHashFn { |
| static unsigned GetHash(const ::device::mojom::NDEFCompatibility& value) { |
| using utype = std::underlying_type<::device::mojom::NDEFCompatibility>::type; |
| return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value)); |
| } |
| static bool Equal(const ::device::mojom::NDEFCompatibility& left, const ::device::mojom::NDEFCompatibility& right) { |
| return left == right; |
| } |
| static const bool safe_to_compare_to_empty_or_deleted = true; |
| }; |
| |
| template <> |
| struct HashTraits<::device::mojom::NDEFCompatibility> |
| : public GenericHashTraits<::device::mojom::NDEFCompatibility> { |
| static_assert(true, |
| "-1000000 is a reserved enum value"); |
| static_assert(true, |
| "-1000001 is a reserved enum value"); |
| static const bool hasIsEmptyValueFunction = true; |
| static bool IsEmptyValue(const ::device::mojom::NDEFCompatibility& value) { |
| return value == static_cast<::device::mojom::NDEFCompatibility>(-1000000); |
| } |
| static void ConstructDeletedValue(::device::mojom::NDEFCompatibility& slot, bool) { |
| slot = static_cast<::device::mojom::NDEFCompatibility>(-1000001); |
| } |
| static bool IsDeletedValue(const ::device::mojom::NDEFCompatibility& value) { |
| return value == static_cast<::device::mojom::NDEFCompatibility>(-1000001); |
| } |
| }; |
| } // namespace WTF |
| |
| |
| namespace device { |
| namespace mojom { |
| namespace blink { |
| |
| class NFCProxy; |
| |
| template <typename ImplRefTraits> |
| class NFCStub; |
| |
| class NFCRequestValidator; |
| class NFCResponseValidator; |
| |
| |
| // @generated_from: device.mojom.NFC |
| class BLINK_PLATFORM_EXPORT NFC |
| : public NFCInterfaceBase { |
| public: |
| static const char Name_[]; |
| static constexpr uint32_t Version_ = 0; |
| static constexpr bool PassesAssociatedKinds_ = false; |
| static constexpr bool HasSyncMethods_ = false; |
| |
| using Base_ = NFCInterfaceBase; |
| using Proxy_ = NFCProxy; |
| |
| template <typename ImplRefTraits> |
| using Stub_ = NFCStub<ImplRefTraits>; |
| |
| using RequestValidator_ = NFCRequestValidator; |
| using ResponseValidator_ = NFCResponseValidator; |
| enum MethodMinVersions : uint32_t { |
| kSetClientMinVersion = 0, |
| kPushMinVersion = 0, |
| kCancelPushMinVersion = 0, |
| kWatchMinVersion = 0, |
| kCancelWatchMinVersion = 0, |
| kCancelAllWatchesMinVersion = 0, |
| kSuspendNFCOperationsMinVersion = 0, |
| kResumeNFCOperationsMinVersion = 0, |
| }; |
| virtual ~NFC() {} |
| |
| |
| // @generated_from: device.mojom.NFC.SetClient |
| virtual void SetClient(NFCClientPtr client) = 0; |
| |
| |
| using PushCallback = base::OnceCallback<void(NFCErrorPtr)>; |
| |
| // @generated_from: device.mojom.NFC.Push |
| virtual void Push(NDEFMessagePtr message, NFCPushOptionsPtr options, PushCallback callback) = 0; |
| |
| |
| using CancelPushCallback = base::OnceCallback<void(NFCErrorPtr)>; |
| |
| // @generated_from: device.mojom.NFC.CancelPush |
| virtual void CancelPush(NFCPushTarget target, CancelPushCallback callback) = 0; |
| |
| |
| using WatchCallback = base::OnceCallback<void(uint32_t, NFCErrorPtr)>; |
| |
| // @generated_from: device.mojom.NFC.Watch |
| virtual void Watch(NFCReaderOptionsPtr options, WatchCallback callback) = 0; |
| |
| |
| using CancelWatchCallback = base::OnceCallback<void(NFCErrorPtr)>; |
| |
| // @generated_from: device.mojom.NFC.CancelWatch |
| virtual void CancelWatch(uint32_t id, CancelWatchCallback callback) = 0; |
| |
| |
| using CancelAllWatchesCallback = base::OnceCallback<void(NFCErrorPtr)>; |
| |
| // @generated_from: device.mojom.NFC.CancelAllWatches |
| virtual void CancelAllWatches(CancelAllWatchesCallback callback) = 0; |
| |
| |
| // @generated_from: device.mojom.NFC.SuspendNFCOperations |
| virtual void SuspendNFCOperations() = 0; |
| |
| |
| // @generated_from: device.mojom.NFC.ResumeNFCOperations |
| virtual void ResumeNFCOperations() = 0; |
| }; |
| |
| class NFCClientProxy; |
| |
| template <typename ImplRefTraits> |
| class NFCClientStub; |
| |
| class NFCClientRequestValidator; |
| |
| |
| // @generated_from: device.mojom.NFCClient |
| class BLINK_PLATFORM_EXPORT NFCClient |
| : public NFCClientInterfaceBase { |
| public: |
| static const char Name_[]; |
| static constexpr uint32_t Version_ = 0; |
| static constexpr bool PassesAssociatedKinds_ = false; |
| static constexpr bool HasSyncMethods_ = false; |
| |
| using Base_ = NFCClientInterfaceBase; |
| using Proxy_ = NFCClientProxy; |
| |
| template <typename ImplRefTraits> |
| using Stub_ = NFCClientStub<ImplRefTraits>; |
| |
| using RequestValidator_ = NFCClientRequestValidator; |
| using ResponseValidator_ = mojo::PassThroughFilter; |
| enum MethodMinVersions : uint32_t { |
| kOnWatchMinVersion = 0, |
| }; |
| virtual ~NFCClient() {} |
| |
| |
| // @generated_from: device.mojom.NFCClient.OnWatch |
| virtual void OnWatch(const WTF::Vector<uint32_t>& watch_ids, NDEFMessagePtr message) = 0; |
| }; |
| |
| class BLINK_PLATFORM_EXPORT NFCProxy |
| : public NFC { |
| public: |
| using InterfaceType = NFC; |
| |
| explicit NFCProxy(mojo::MessageReceiverWithResponder* receiver); |
| void SetClient(NFCClientPtr client) final; |
| void Push(NDEFMessagePtr message, NFCPushOptionsPtr options, PushCallback callback) final; |
| void CancelPush(NFCPushTarget target, CancelPushCallback callback) final; |
| void Watch(NFCReaderOptionsPtr options, WatchCallback callback) final; |
| void CancelWatch(uint32_t id, CancelWatchCallback callback) final; |
| void CancelAllWatches(CancelAllWatchesCallback callback) final; |
| void SuspendNFCOperations() final; |
| void ResumeNFCOperations() final; |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| |
| class BLINK_PLATFORM_EXPORT NFCClientProxy |
| : public NFCClient { |
| public: |
| using InterfaceType = NFCClient; |
| |
| explicit NFCClientProxy(mojo::MessageReceiverWithResponder* receiver); |
| void OnWatch(const WTF::Vector<uint32_t>& watch_ids, NDEFMessagePtr message) final; |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| class BLINK_PLATFORM_EXPORT NFCStubDispatch { |
| public: |
| static bool Accept(NFC* impl, mojo::Message* message); |
| static bool AcceptWithResponder( |
| NFC* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder); |
| }; |
| |
| template <typename ImplRefTraits = |
| mojo::RawPtrImplRefTraits<NFC>> |
| class NFCStub |
| : public mojo::MessageReceiverWithResponderStatus { |
| public: |
| using ImplPointerType = typename ImplRefTraits::PointerType; |
| |
| NFCStub() {} |
| ~NFCStub() override {} |
| |
| 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 NFCStubDispatch::Accept( |
| ImplRefTraits::GetRawPointer(&sink_), message); |
| } |
| |
| bool AcceptWithResponder( |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return NFCStubDispatch::AcceptWithResponder( |
| ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); |
| } |
| |
| private: |
| ImplPointerType sink_; |
| }; |
| class BLINK_PLATFORM_EXPORT NFCClientStubDispatch { |
| public: |
| static bool Accept(NFCClient* impl, mojo::Message* message); |
| static bool AcceptWithResponder( |
| NFCClient* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder); |
| }; |
| |
| template <typename ImplRefTraits = |
| mojo::RawPtrImplRefTraits<NFCClient>> |
| class NFCClientStub |
| : public mojo::MessageReceiverWithResponderStatus { |
| public: |
| using ImplPointerType = typename ImplRefTraits::PointerType; |
| |
| NFCClientStub() {} |
| ~NFCClientStub() override {} |
| |
| 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 NFCClientStubDispatch::Accept( |
| ImplRefTraits::GetRawPointer(&sink_), message); |
| } |
| |
| bool AcceptWithResponder( |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return NFCClientStubDispatch::AcceptWithResponder( |
| ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); |
| } |
| |
| private: |
| ImplPointerType sink_; |
| }; |
| class BLINK_PLATFORM_EXPORT NFCRequestValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class BLINK_PLATFORM_EXPORT NFCClientRequestValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class BLINK_PLATFORM_EXPORT NFCResponseValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| |
| |
| |
| |
| |
| // @generated_from: device.mojom.NFCError |
| class BLINK_PLATFORM_EXPORT NFCError { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<NFCError, T>::value>; |
| using DataView = NFCErrorDataView; |
| using Data_ = internal::NFCError_Data; |
| |
| template <typename... Args> |
| static NFCErrorPtr New(Args&&... args) { |
| return NFCErrorPtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static NFCErrorPtr From(const U& u) { |
| return mojo::TypeConverter<NFCErrorPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, NFCError>::Convert(*this); |
| } |
| |
| |
| NFCError(); |
| |
| explicit NFCError( |
| NFCErrorType error_type); |
| |
| ~NFCError(); |
| |
| // 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 = NFCErrorPtr> |
| NFCErrorPtr 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, NFCError::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| size_t Hash(size_t seed) const; |
| |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| NFCError::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| NFCError::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::NFCError_UnserializedMessageContext< |
| UserType, NFCError::DataView>>(0, 0, std::move(input))); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| return mojo::internal::DeserializeImpl<NFCError::DataView>( |
| data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return NFCError::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::NFCError_UnserializedMessageContext< |
| UserType, NFCError::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<NFCError::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: device.mojom.NFCError.error_type |
| NFCErrorType error_type; |
| |
| 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, NFCError::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, NFCError::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, NFCError::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, NFCError::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| |
| |
| // @generated_from: device.mojom.NFCPushOptions |
| class BLINK_PLATFORM_EXPORT NFCPushOptions { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<NFCPushOptions, T>::value>; |
| using DataView = NFCPushOptionsDataView; |
| using Data_ = internal::NFCPushOptions_Data; |
| |
| template <typename... Args> |
| static NFCPushOptionsPtr New(Args&&... args) { |
| return NFCPushOptionsPtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static NFCPushOptionsPtr From(const U& u) { |
| return mojo::TypeConverter<NFCPushOptionsPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, NFCPushOptions>::Convert(*this); |
| } |
| |
| |
| NFCPushOptions(); |
| |
| NFCPushOptions( |
| NFCPushTarget target, |
| double timeout, |
| bool ignore_read, |
| NDEFCompatibility compatibility); |
| |
| ~NFCPushOptions(); |
| |
| // 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 = NFCPushOptionsPtr> |
| NFCPushOptionsPtr 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, NFCPushOptions::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| size_t Hash(size_t seed) const; |
| |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| NFCPushOptions::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| NFCPushOptions::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::NFCPushOptions_UnserializedMessageContext< |
| UserType, NFCPushOptions::DataView>>(0, 0, std::move(input))); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| return mojo::internal::DeserializeImpl<NFCPushOptions::DataView>( |
| data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return NFCPushOptions::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::NFCPushOptions_UnserializedMessageContext< |
| UserType, NFCPushOptions::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<NFCPushOptions::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: device.mojom.NFCPushOptions.target |
| NFCPushTarget target; |
| |
| // @generated_from: device.mojom.NFCPushOptions.timeout |
| double timeout; |
| |
| // @generated_from: device.mojom.NFCPushOptions.ignore_read |
| bool ignore_read; |
| |
| // @generated_from: device.mojom.NFCPushOptions.compatibility |
| NDEFCompatibility compatibility; |
| |
| 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, NFCPushOptions::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, NFCPushOptions::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, NFCPushOptions::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, NFCPushOptions::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: device.mojom.NDEFRecordTypeFilter |
| class BLINK_PLATFORM_EXPORT NDEFRecordTypeFilter { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<NDEFRecordTypeFilter, T>::value>; |
| using DataView = NDEFRecordTypeFilterDataView; |
| using Data_ = internal::NDEFRecordTypeFilter_Data; |
| |
| template <typename... Args> |
| static NDEFRecordTypeFilterPtr New(Args&&... args) { |
| return NDEFRecordTypeFilterPtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static NDEFRecordTypeFilterPtr From(const U& u) { |
| return mojo::TypeConverter<NDEFRecordTypeFilterPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, NDEFRecordTypeFilter>::Convert(*this); |
| } |
| |
| |
| NDEFRecordTypeFilter(); |
| |
| explicit NDEFRecordTypeFilter( |
| NDEFRecordType record_type); |
| |
| ~NDEFRecordTypeFilter(); |
| |
| // 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 = NDEFRecordTypeFilterPtr> |
| NDEFRecordTypeFilterPtr 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, NDEFRecordTypeFilter::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| size_t Hash(size_t seed) const; |
| |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| NDEFRecordTypeFilter::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| NDEFRecordTypeFilter::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::NDEFRecordTypeFilter_UnserializedMessageContext< |
| UserType, NDEFRecordTypeFilter::DataView>>(0, 0, std::move(input))); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| return mojo::internal::DeserializeImpl<NDEFRecordTypeFilter::DataView>( |
| data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return NDEFRecordTypeFilter::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::NDEFRecordTypeFilter_UnserializedMessageContext< |
| UserType, NDEFRecordTypeFilter::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<NDEFRecordTypeFilter::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: device.mojom.NDEFRecordTypeFilter.record_type |
| NDEFRecordType record_type; |
| |
| 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, NDEFRecordTypeFilter::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, NDEFRecordTypeFilter::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, NDEFRecordTypeFilter::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, NDEFRecordTypeFilter::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| // @generated_from: device.mojom.NDEFRecord |
| class BLINK_PLATFORM_EXPORT NDEFRecord { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<NDEFRecord, T>::value>; |
| using DataView = NDEFRecordDataView; |
| using Data_ = internal::NDEFRecord_Data; |
| |
| template <typename... Args> |
| static NDEFRecordPtr New(Args&&... args) { |
| return NDEFRecordPtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static NDEFRecordPtr From(const U& u) { |
| return mojo::TypeConverter<NDEFRecordPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, NDEFRecord>::Convert(*this); |
| } |
| |
| |
| NDEFRecord(); |
| |
| NDEFRecord( |
| NDEFRecordType record_type, |
| const WTF::String& media_type, |
| const WTF::Vector<uint8_t>& data); |
| |
| ~NDEFRecord(); |
| |
| // 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 = NDEFRecordPtr> |
| NDEFRecordPtr 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, NDEFRecord::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| NDEFRecord::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| NDEFRecord::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::NDEFRecord_UnserializedMessageContext< |
| UserType, NDEFRecord::DataView>>(0, 0, std::move(input))); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| return mojo::internal::DeserializeImpl<NDEFRecord::DataView>( |
| data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return NDEFRecord::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::NDEFRecord_UnserializedMessageContext< |
| UserType, NDEFRecord::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<NDEFRecord::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: device.mojom.NDEFRecord.record_type |
| NDEFRecordType record_type; |
| |
| // @generated_from: device.mojom.NDEFRecord.media_type |
| WTF::String media_type; |
| |
| // @generated_from: device.mojom.NDEFRecord.data |
| WTF::Vector<uint8_t> data; |
| |
| 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, NDEFRecord::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, NDEFRecord::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, NDEFRecord::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, NDEFRecord::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: device.mojom.NDEFMessage |
| class BLINK_PLATFORM_EXPORT NDEFMessage { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<NDEFMessage, T>::value>; |
| using DataView = NDEFMessageDataView; |
| using Data_ = internal::NDEFMessage_Data; |
| |
| // @generated_from: device.mojom.NDEFMessage.kMaxSize |
| static constexpr uint32_t kMaxSize = 32768U; |
| |
| template <typename... Args> |
| static NDEFMessagePtr New(Args&&... args) { |
| return NDEFMessagePtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static NDEFMessagePtr From(const U& u) { |
| return mojo::TypeConverter<NDEFMessagePtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, NDEFMessage>::Convert(*this); |
| } |
| |
| |
| NDEFMessage(); |
| |
| NDEFMessage( |
| WTF::Vector<NDEFRecordPtr> data, |
| const WTF::String& url); |
| |
| ~NDEFMessage(); |
| |
| // 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 = NDEFMessagePtr> |
| NDEFMessagePtr 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, NDEFMessage::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| NDEFMessage::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| NDEFMessage::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::NDEFMessage_UnserializedMessageContext< |
| UserType, NDEFMessage::DataView>>(0, 0, std::move(input))); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| return mojo::internal::DeserializeImpl<NDEFMessage::DataView>( |
| data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return NDEFMessage::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::NDEFMessage_UnserializedMessageContext< |
| UserType, NDEFMessage::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<NDEFMessage::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: device.mojom.NDEFMessage.data |
| WTF::Vector<NDEFRecordPtr> data; |
| |
| // @generated_from: device.mojom.NDEFMessage.url |
| WTF::String url; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| DISALLOW_COPY_AND_ASSIGN(NDEFMessage); |
| }; |
| |
| // 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, NDEFMessage::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, NDEFMessage::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, NDEFMessage::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, NDEFMessage::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| |
| |
| // @generated_from: device.mojom.NFCReaderOptions |
| class BLINK_PLATFORM_EXPORT NFCReaderOptions { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<NFCReaderOptions, T>::value>; |
| using DataView = NFCReaderOptionsDataView; |
| using Data_ = internal::NFCReaderOptions_Data; |
| |
| template <typename... Args> |
| static NFCReaderOptionsPtr New(Args&&... args) { |
| return NFCReaderOptionsPtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static NFCReaderOptionsPtr From(const U& u) { |
| return mojo::TypeConverter<NFCReaderOptionsPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, NFCReaderOptions>::Convert(*this); |
| } |
| |
| |
| NFCReaderOptions(); |
| |
| NFCReaderOptions( |
| const WTF::String& url, |
| NDEFRecordTypeFilterPtr record_filter, |
| const WTF::String& media_type, |
| NDEFCompatibility compatibility); |
| |
| ~NFCReaderOptions(); |
| |
| // 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 = NFCReaderOptionsPtr> |
| NFCReaderOptionsPtr 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, NFCReaderOptions::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| NFCReaderOptions::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| NFCReaderOptions::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::NFCReaderOptions_UnserializedMessageContext< |
| UserType, NFCReaderOptions::DataView>>(0, 0, std::move(input))); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| return mojo::internal::DeserializeImpl<NFCReaderOptions::DataView>( |
| data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return NFCReaderOptions::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::NFCReaderOptions_UnserializedMessageContext< |
| UserType, NFCReaderOptions::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<NFCReaderOptions::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: device.mojom.NFCReaderOptions.url |
| WTF::String url; |
| |
| // @generated_from: device.mojom.NFCReaderOptions.record_filter |
| NDEFRecordTypeFilterPtr record_filter; |
| |
| // @generated_from: device.mojom.NFCReaderOptions.media_type |
| WTF::String media_type; |
| |
| // @generated_from: device.mojom.NFCReaderOptions.compatibility |
| NDEFCompatibility compatibility; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| DISALLOW_COPY_AND_ASSIGN(NFCReaderOptions); |
| }; |
| |
| // 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, NFCReaderOptions::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, NFCReaderOptions::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, NFCReaderOptions::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, NFCReaderOptions::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| template <typename StructPtrType> |
| NFCErrorPtr NFCError::Clone() const { |
| return New( |
| mojo::Clone(error_type) |
| ); |
| } |
| |
| template <typename T, NFCError::EnableIfSame<T>*> |
| bool NFCError::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->error_type, other_struct.error_type)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, NFCError::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.error_type < rhs.error_type) |
| return true; |
| if (rhs.error_type < lhs.error_type) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| NDEFRecordPtr NDEFRecord::Clone() const { |
| return New( |
| mojo::Clone(record_type), |
| mojo::Clone(media_type), |
| mojo::Clone(data) |
| ); |
| } |
| |
| template <typename T, NDEFRecord::EnableIfSame<T>*> |
| bool NDEFRecord::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->record_type, other_struct.record_type)) |
| return false; |
| if (!mojo::Equals(this->media_type, other_struct.media_type)) |
| return false; |
| if (!mojo::Equals(this->data, other_struct.data)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, NDEFRecord::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.record_type < rhs.record_type) |
| return true; |
| if (rhs.record_type < lhs.record_type) |
| return false; |
| if (lhs.media_type < rhs.media_type) |
| return true; |
| if (rhs.media_type < lhs.media_type) |
| return false; |
| if (lhs.data < rhs.data) |
| return true; |
| if (rhs.data < lhs.data) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| NDEFMessagePtr NDEFMessage::Clone() const { |
| return New( |
| mojo::Clone(data), |
| mojo::Clone(url) |
| ); |
| } |
| |
| template <typename T, NDEFMessage::EnableIfSame<T>*> |
| bool NDEFMessage::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->data, other_struct.data)) |
| return false; |
| if (!mojo::Equals(this->url, other_struct.url)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, NDEFMessage::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.data < rhs.data) |
| return true; |
| if (rhs.data < lhs.data) |
| return false; |
| if (lhs.url < rhs.url) |
| return true; |
| if (rhs.url < lhs.url) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| NFCPushOptionsPtr NFCPushOptions::Clone() const { |
| return New( |
| mojo::Clone(target), |
| mojo::Clone(timeout), |
| mojo::Clone(ignore_read), |
| mojo::Clone(compatibility) |
| ); |
| } |
| |
| template <typename T, NFCPushOptions::EnableIfSame<T>*> |
| bool NFCPushOptions::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->target, other_struct.target)) |
| return false; |
| if (!mojo::Equals(this->timeout, other_struct.timeout)) |
| return false; |
| if (!mojo::Equals(this->ignore_read, other_struct.ignore_read)) |
| return false; |
| if (!mojo::Equals(this->compatibility, other_struct.compatibility)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, NFCPushOptions::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.target < rhs.target) |
| return true; |
| if (rhs.target < lhs.target) |
| return false; |
| if (lhs.timeout < rhs.timeout) |
| return true; |
| if (rhs.timeout < lhs.timeout) |
| return false; |
| if (lhs.ignore_read < rhs.ignore_read) |
| return true; |
| if (rhs.ignore_read < lhs.ignore_read) |
| return false; |
| if (lhs.compatibility < rhs.compatibility) |
| return true; |
| if (rhs.compatibility < lhs.compatibility) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| NDEFRecordTypeFilterPtr NDEFRecordTypeFilter::Clone() const { |
| return New( |
| mojo::Clone(record_type) |
| ); |
| } |
| |
| template <typename T, NDEFRecordTypeFilter::EnableIfSame<T>*> |
| bool NDEFRecordTypeFilter::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->record_type, other_struct.record_type)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, NDEFRecordTypeFilter::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.record_type < rhs.record_type) |
| return true; |
| if (rhs.record_type < lhs.record_type) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| NFCReaderOptionsPtr NFCReaderOptions::Clone() const { |
| return New( |
| mojo::Clone(url), |
| mojo::Clone(record_filter), |
| mojo::Clone(media_type), |
| mojo::Clone(compatibility) |
| ); |
| } |
| |
| template <typename T, NFCReaderOptions::EnableIfSame<T>*> |
| bool NFCReaderOptions::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->url, other_struct.url)) |
| return false; |
| if (!mojo::Equals(this->record_filter, other_struct.record_filter)) |
| return false; |
| if (!mojo::Equals(this->media_type, other_struct.media_type)) |
| return false; |
| if (!mojo::Equals(this->compatibility, other_struct.compatibility)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, NFCReaderOptions::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.url < rhs.url) |
| return true; |
| if (rhs.url < lhs.url) |
| return false; |
| if (lhs.record_filter < rhs.record_filter) |
| return true; |
| if (rhs.record_filter < lhs.record_filter) |
| return false; |
| if (lhs.media_type < rhs.media_type) |
| return true; |
| if (rhs.media_type < lhs.media_type) |
| return false; |
| if (lhs.compatibility < rhs.compatibility) |
| return true; |
| if (rhs.compatibility < lhs.compatibility) |
| return false; |
| return false; |
| } |
| |
| |
| } // namespace blink |
| } // namespace mojom |
| } // namespace device |
| |
| namespace mojo { |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::device::mojom::blink::NFCError::DataView, |
| ::device::mojom::blink::NFCErrorPtr> { |
| static bool IsNull(const ::device::mojom::blink::NFCErrorPtr& input) { return !input; } |
| static void SetToNull(::device::mojom::blink::NFCErrorPtr* output) { output->reset(); } |
| |
| static decltype(::device::mojom::blink::NFCError::error_type) error_type( |
| const ::device::mojom::blink::NFCErrorPtr& input) { |
| return input->error_type; |
| } |
| |
| static bool Read(::device::mojom::blink::NFCError::DataView input, ::device::mojom::blink::NFCErrorPtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::device::mojom::blink::NDEFRecord::DataView, |
| ::device::mojom::blink::NDEFRecordPtr> { |
| static bool IsNull(const ::device::mojom::blink::NDEFRecordPtr& input) { return !input; } |
| static void SetToNull(::device::mojom::blink::NDEFRecordPtr* output) { output->reset(); } |
| |
| static decltype(::device::mojom::blink::NDEFRecord::record_type) record_type( |
| const ::device::mojom::blink::NDEFRecordPtr& input) { |
| return input->record_type; |
| } |
| |
| static const decltype(::device::mojom::blink::NDEFRecord::media_type)& media_type( |
| const ::device::mojom::blink::NDEFRecordPtr& input) { |
| return input->media_type; |
| } |
| |
| static const decltype(::device::mojom::blink::NDEFRecord::data)& data( |
| const ::device::mojom::blink::NDEFRecordPtr& input) { |
| return input->data; |
| } |
| |
| static bool Read(::device::mojom::blink::NDEFRecord::DataView input, ::device::mojom::blink::NDEFRecordPtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::device::mojom::blink::NDEFMessage::DataView, |
| ::device::mojom::blink::NDEFMessagePtr> { |
| static bool IsNull(const ::device::mojom::blink::NDEFMessagePtr& input) { return !input; } |
| static void SetToNull(::device::mojom::blink::NDEFMessagePtr* output) { output->reset(); } |
| |
| static const decltype(::device::mojom::blink::NDEFMessage::data)& data( |
| const ::device::mojom::blink::NDEFMessagePtr& input) { |
| return input->data; |
| } |
| |
| static const decltype(::device::mojom::blink::NDEFMessage::url)& url( |
| const ::device::mojom::blink::NDEFMessagePtr& input) { |
| return input->url; |
| } |
| |
| static bool Read(::device::mojom::blink::NDEFMessage::DataView input, ::device::mojom::blink::NDEFMessagePtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::device::mojom::blink::NFCPushOptions::DataView, |
| ::device::mojom::blink::NFCPushOptionsPtr> { |
| static bool IsNull(const ::device::mojom::blink::NFCPushOptionsPtr& input) { return !input; } |
| static void SetToNull(::device::mojom::blink::NFCPushOptionsPtr* output) { output->reset(); } |
| |
| static decltype(::device::mojom::blink::NFCPushOptions::target) target( |
| const ::device::mojom::blink::NFCPushOptionsPtr& input) { |
| return input->target; |
| } |
| |
| static decltype(::device::mojom::blink::NFCPushOptions::timeout) timeout( |
| const ::device::mojom::blink::NFCPushOptionsPtr& input) { |
| return input->timeout; |
| } |
| |
| static decltype(::device::mojom::blink::NFCPushOptions::ignore_read) ignore_read( |
| const ::device::mojom::blink::NFCPushOptionsPtr& input) { |
| return input->ignore_read; |
| } |
| |
| static decltype(::device::mojom::blink::NFCPushOptions::compatibility) compatibility( |
| const ::device::mojom::blink::NFCPushOptionsPtr& input) { |
| return input->compatibility; |
| } |
| |
| static bool Read(::device::mojom::blink::NFCPushOptions::DataView input, ::device::mojom::blink::NFCPushOptionsPtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::device::mojom::blink::NDEFRecordTypeFilter::DataView, |
| ::device::mojom::blink::NDEFRecordTypeFilterPtr> { |
| static bool IsNull(const ::device::mojom::blink::NDEFRecordTypeFilterPtr& input) { return !input; } |
| static void SetToNull(::device::mojom::blink::NDEFRecordTypeFilterPtr* output) { output->reset(); } |
| |
| static decltype(::device::mojom::blink::NDEFRecordTypeFilter::record_type) record_type( |
| const ::device::mojom::blink::NDEFRecordTypeFilterPtr& input) { |
| return input->record_type; |
| } |
| |
| static bool Read(::device::mojom::blink::NDEFRecordTypeFilter::DataView input, ::device::mojom::blink::NDEFRecordTypeFilterPtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::device::mojom::blink::NFCReaderOptions::DataView, |
| ::device::mojom::blink::NFCReaderOptionsPtr> { |
| static bool IsNull(const ::device::mojom::blink::NFCReaderOptionsPtr& input) { return !input; } |
| static void SetToNull(::device::mojom::blink::NFCReaderOptionsPtr* output) { output->reset(); } |
| |
| static const decltype(::device::mojom::blink::NFCReaderOptions::url)& url( |
| const ::device::mojom::blink::NFCReaderOptionsPtr& input) { |
| return input->url; |
| } |
| |
| static const decltype(::device::mojom::blink::NFCReaderOptions::record_filter)& record_filter( |
| const ::device::mojom::blink::NFCReaderOptionsPtr& input) { |
| return input->record_filter; |
| } |
| |
| static const decltype(::device::mojom::blink::NFCReaderOptions::media_type)& media_type( |
| const ::device::mojom::blink::NFCReaderOptionsPtr& input) { |
| return input->media_type; |
| } |
| |
| static decltype(::device::mojom::blink::NFCReaderOptions::compatibility) compatibility( |
| const ::device::mojom::blink::NFCReaderOptionsPtr& input) { |
| return input->compatibility; |
| } |
| |
| static bool Read(::device::mojom::blink::NFCReaderOptions::DataView input, ::device::mojom::blink::NFCReaderOptionsPtr* output); |
| }; |
| |
| } // namespace mojo |
| |
| #endif // SERVICES_DEVICE_PUBLIC_MOJOM_NFC_MOJOM_BLINK_H_
|
| /* Metadata comment
|
| eyJtZXRhIjogW3siZW5kIjogNzY1NiwgImJlZ2luIjogNzY1MywgImVkZ2UiOiAiJS9reXRoZS9l
|
| ZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3Jw
|
| dXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2Ui
|
| OiAibW9qb20iLCAic2lnbmF0dXJlIjogImRldmljZS5tb2pvbS5ORkMifX0sIHsiZW5kIjogODUx
|
| NCwgImJlZ2luIjogODUwNSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBl
|
| IjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xl
|
| c291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJl
|
| IjogImRldmljZS5tb2pvbS5ORkMuU2V0Q2xpZW50In19LCB7ImVuZCI6IDg2NjksICJiZWdpbiI6
|
| IDg2NjUsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3Jf
|
| ZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20v
|
| Y2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJkZXZpY2Uu
|
| bW9qb20uTkZDLlB1c2gifX0sIHsiZW5kIjogODg5NSwgImJlZ2luIjogODg4NSwgImVkZ2UiOiAi
|
| JS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1l
|
| IjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAi
|
| bGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImRldmljZS5tb2pvbS5ORkMuQ2FuY2Vs
|
| UHVzaCJ9fSwgeyJlbmQiOiA5MDkzLCAiYmVnaW4iOiA5MDg4LCAiZWRnZSI6ICIlL2t5dGhlL2Vk
|
| Z2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1
|
| cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6
|
| ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiZGV2aWNlLm1vam9tLk5GQy5XYXRjaCJ9fSwgeyJlbmQi
|
| OiA5MzAxLCAiYmVnaW4iOiA5MjkwLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwg
|
| InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5n
|
| b29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWdu
|
| YXR1cmUiOiAiZGV2aWNlLm1vam9tLk5GQy5DYW5jZWxXYXRjaCJ9fSwgeyJlbmQiOiA5NTE0LCAi
|
| YmVnaW4iOiA5NDk4LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAi
|
| YW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3Vy
|
| Y2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAi
|
| ZGV2aWNlLm1vam9tLk5GQy5DYW5jZWxBbGxXYXRjaGVzIn19LCB7ImVuZCI6IDk2NTIsICJiZWdp
|
| biI6IDk2MzIsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNo
|
| b3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5j
|
| b20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJkZXZp
|
| Y2UubW9qb20uTkZDLlN1c3BlbmRORkNPcGVyYXRpb25zIn19LCB7ImVuZCI6IDk3NTUsICJiZWdp
|
| biI6IDk3MzYsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNo
|
| b3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5j
|
| b20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJkZXZp
|
| Y2UubW9qb20uTkZDLlJlc3VtZU5GQ09wZXJhdGlvbnMifX0sIHsiZW5kIjogOTk2MSwgImJlZ2lu
|
| IjogOTk1MiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hv
|
| cl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNv
|
| bS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImRldmlj
|
| ZS5tb2pvbS5ORkNDbGllbnQifX0sIHsiZW5kIjogMTA2MjYsICJiZWdpbiI6IDEwNjE5LCAiZWRn
|
| ZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAi
|
| dm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3Ny
|
| YyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiZGV2aWNlLm1vam9tLk5GQ0Ns
|
| aWVudC5PbldhdGNoIn19LCB7ImVuZCI6IDE0NzQxLCAiYmVnaW4iOiAxNDczMywgImVkZ2UiOiAi
|
| JS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1l
|
| IjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAi
|
| bGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImRldmljZS5tb2pvbS5ORkNFcnJvciJ9
|
| fSwgeyJlbmQiOiAxODE2NSwgImJlZ2luIjogMTgxNTUsICJlZGdlIjogIiUva3l0aGUvZWRnZS9n
|
| ZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjog
|
| ImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1v
|
| am9tIiwgInNpZ25hdHVyZSI6ICJkZXZpY2UubW9qb20uTkZDRXJyb3IuZXJyb3JfdHlwZSJ9fSwg
|
| eyJlbmQiOiAxOTA5OSwgImJlZ2luIjogMTkwODUsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5l
|
| cmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNo
|
| cm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9t
|
| IiwgInNpZ25hdHVyZSI6ICJkZXZpY2UubW9qb20uTkZDUHVzaE9wdGlvbnMifX0sIHsiZW5kIjog
|
| MjI3MzMsICJiZWdpbiI6IDIyNzI3LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwg
|
| InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5n
|
| b29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWdu
|
| YXR1cmUiOiAiZGV2aWNlLm1vam9tLk5GQ1B1c2hPcHRpb25zLnRhcmdldCJ9fSwgeyJlbmQiOiAy
|
| MjgxMCwgImJlZ2luIjogMjI4MDMsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAi
|
| dHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdv
|
| b2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25h
|
| dHVyZSI6ICJkZXZpY2UubW9qb20uTkZDUHVzaE9wdGlvbnMudGltZW91dCJ9fSwgeyJlbmQiOiAy
|
| Mjg5MywgImJlZ2luIjogMjI4ODIsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAi
|
| dHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdv
|
| b2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25h
|
| dHVyZSI6ICJkZXZpY2UubW9qb20uTkZDUHVzaE9wdGlvbnMuaWdub3JlX3JlYWQifX0sIHsiZW5k
|
| IjogMjI5OTMsICJiZWdpbiI6IDIyOTgwLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVz
|
| IiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1
|
| bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJz
|
| aWduYXR1cmUiOiAiZGV2aWNlLm1vam9tLk5GQ1B1c2hPcHRpb25zLmNvbXBhdGliaWxpdHkifX0s
|
| IHsiZW5kIjogMjM5NjEsICJiZWdpbiI6IDIzOTQxLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2Vu
|
| ZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJj
|
| aHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pv
|
| bSIsICJzaWduYXR1cmUiOiAiZGV2aWNlLm1vam9tLk5ERUZSZWNvcmRUeXBlRmlsdGVyIn19LCB7
|
| ImVuZCI6IDI3NjgwLCAiYmVnaW4iOiAyNzY2OSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVy
|
| YXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hy
|
| b21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20i
|
| LCAic2lnbmF0dXJlIjogImRldmljZS5tb2pvbS5OREVGUmVjb3JkVHlwZUZpbHRlci5yZWNvcmRf
|
| dHlwZSJ9fSwgeyJlbmQiOiAyODY1NiwgImJlZ2luIjogMjg2NDYsICJlZGdlIjogIiUva3l0aGUv
|
| ZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29y
|
| cHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdl
|
| IjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJkZXZpY2UubW9qb20uTkRFRlJlY29yZCJ9fSwgeyJl
|
| bmQiOiAzMjE2OSwgImJlZ2luIjogMzIxNTgsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0
|
| ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9t
|
| aXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwg
|
| InNpZ25hdHVyZSI6ICJkZXZpY2UubW9qb20uTkRFRlJlY29yZC5yZWNvcmRfdHlwZSJ9fSwgeyJl
|
| bmQiOiAzMjI1MywgImJlZ2luIjogMzIyNDMsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0
|
| ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9t
|
| aXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwg
|
| InNpZ25hdHVyZSI6ICJkZXZpY2UubW9qb20uTkRFRlJlY29yZC5tZWRpYV90eXBlIn19LCB7ImVu
|
| ZCI6IDMyMzM0LCAiYmVnaW4iOiAzMjMzMCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRl
|
| cyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21p
|
| dW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAi
|
| c2lnbmF0dXJlIjogImRldmljZS5tb2pvbS5OREVGUmVjb3JkLmRhdGEifX0sIHsiZW5kIjogMzMy
|
| NjgsICJiZWdpbiI6IDMzMjU3LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5
|
| cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29n
|
| bGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1
|
| cmUiOiAiZGV2aWNlLm1vam9tLk5ERUZNZXNzYWdlIn19LCB7ImVuZCI6IDMzNTU5LCAiYmVnaW4i
|
| OiAzMzU1MSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hv
|
| cl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNv
|
| bS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImRldmlj
|
| ZS5tb2pvbS5OREVGTWVzc2FnZS5rTWF4U2l6ZSJ9fSwgeyJlbmQiOiAzNjg2NSwgImJlZ2luIjog
|
| MzY4NjEsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3Jf
|
| ZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20v
|
| Y2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJkZXZpY2Uu
|
| bW9qb20uTkRFRk1lc3NhZ2UuZGF0YSJ9fSwgeyJlbmQiOiAzNjkzNiwgImJlZ2luIjogMzY5MzMs
|
| ICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5l
|
| cyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21p
|
| dW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJkZXZpY2UubW9qb20u
|
| TkRFRk1lc3NhZ2UudXJsIn19LCB7ImVuZCI6IDM3OTI3LCAiYmVnaW4iOiAzNzkxMSwgImVkZ2Ui
|
| OiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZu
|
| YW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMi
|
| LCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImRldmljZS5tb2pvbS5ORkNSZWFk
|
| ZXJPcHRpb25zIn19LCB7ImVuZCI6IDQxNjA1LCAiYmVnaW4iOiA0MTYwMiwgImVkZ2UiOiAiJS9r
|
| eXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjog
|
| eyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFu
|
| Z3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImRldmljZS5tb2pvbS5ORkNSZWFkZXJPcHRp
|
| b25zLnVybCJ9fSwgeyJlbmQiOiA0MTcxMywgImJlZ2luIjogNDE3MDAsICJlZGdlIjogIiUva3l0
|
| aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsi
|
| Y29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1
|
| YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJkZXZpY2UubW9qb20uTkZDUmVhZGVyT3B0aW9u
|
| cy5yZWNvcmRfZmlsdGVyIn19LCB7ImVuZCI6IDQxODAzLCAiYmVnaW4iOiA0MTc5MywgImVkZ2Ui
|
| OiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZu
|
| YW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMi
|
| LCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImRldmljZS5tb2pvbS5ORkNSZWFk
|
| ZXJPcHRpb25zLm1lZGlhX3R5cGUifX0sIHsiZW5kIjogNDE5MDUsICJiZWdpbiI6IDQxODkyLCAi
|
| ZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMi
|
| LCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVt
|
| L3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiZGV2aWNlLm1vam9tLk5G
|
| Q1JlYWRlck9wdGlvbnMuY29tcGF0aWJpbGl0eSJ9fV0sICJ0eXBlIjogImt5dGhlMCJ9
|
| */ |