| // WARNING: This file is machine generated by fidlgen. |
| |
| // fidl_experiment = output_index_json |
| |
| #pragma once |
| |
| #include <fidl/test.typesinprotocols/cpp/natural_types.h> |
| #include <lib/fidl/cpp/hlcpp_conversion.h> |
| #include <lib/fidl/cpp/wire/service_handler.h> |
| #include <test/typesinprotocols/cpp/fidl.h> |
| |
| #pragma clang diagnostic push |
| #pragma clang diagnostic ignored "-Wshadow" |
| |
| namespace fidl { |
| namespace internal { |
| |
| template <> |
| struct NaturalToHLCPPTraits<::test_typesinprotocols::Enum> : public NaturalToHLCPPTraitsEnum<::test_typesinprotocols::Enum, ::test::typesinprotocols::Enum, uint32_t> {}; |
| template <> |
| struct HLCPPToNaturalTraits<::test::typesinprotocols::Enum> : public HLCPPToNaturalTraitsEnum<::test::typesinprotocols::Enum, ::test_typesinprotocols::Enum> {}; |
| template <> |
| struct NaturalToHLCPPTraits<::test_typesinprotocols::Bits> : public NaturalToHLCPPTraitsBits<::test_typesinprotocols::Bits, ::test::typesinprotocols::Bits, uint32_t> {}; |
| template <> |
| struct HLCPPToNaturalTraits<::test::typesinprotocols::Bits> : public HLCPPToNaturalTraitsBits<::test::typesinprotocols::Bits, ::test_typesinprotocols::Bits, uint32_t> {}; |
| |
| template <> |
| struct NaturalToHLCPPTraits<fidl::ClientEnd<::test_typesinprotocols::Protocol>> { |
| using HLCPPType = fidl::InterfaceHandle<::test::typesinprotocols::Protocol>; |
| static inline fidl::InterfaceHandle<::test::typesinprotocols::Protocol> Convert(fidl::ClientEnd<::test_typesinprotocols::Protocol>&& c) { |
| return fidl::InterfaceHandle<::test::typesinprotocols::Protocol>(c.TakeChannel()); |
| } |
| }; |
| |
| template <> |
| struct NaturalToHLCPPTraits<fidl::ServerEnd<::test_typesinprotocols::Protocol>> { |
| using HLCPPType = fidl::InterfaceRequest<::test::typesinprotocols::Protocol>; |
| static inline fidl::InterfaceRequest<::test::typesinprotocols::Protocol> Convert(fidl::ServerEnd<::test_typesinprotocols::Protocol>&& c) { |
| return fidl::InterfaceRequest<::test::typesinprotocols::Protocol>(c.TakeChannel()); |
| } |
| }; |
| |
| template <> |
| struct HLCPPToNaturalTraits<fidl::InterfaceHandle<::test::typesinprotocols::Protocol>> { |
| using NaturalType = fidl::ClientEnd<::test_typesinprotocols::Protocol>; |
| static inline fidl::ClientEnd<::test_typesinprotocols::Protocol> Convert(fidl::InterfaceHandle<::test::typesinprotocols::Protocol>&& c) { |
| return fidl::ClientEnd<::test_typesinprotocols::Protocol>(c.TakeChannel()); |
| } |
| }; |
| |
| template <> |
| struct HLCPPToNaturalTraits<fidl::InterfaceRequest<::test::typesinprotocols::Protocol>> { |
| using NaturalType = fidl::ServerEnd<::test_typesinprotocols::Protocol>; |
| static inline fidl::ServerEnd<::test_typesinprotocols::Protocol> Convert(fidl::InterfaceRequest<::test::typesinprotocols::Protocol>&& c) { |
| return fidl::ServerEnd<::test_typesinprotocols::Protocol>(c.TakeChannel()); |
| } |
| }; |
| |
| template <> |
| struct NaturalToHLCPPTraits<fidl::ProtocolHandler<::test_typesinprotocols::Protocol>> { |
| using HLCPPType = fidl::InterfaceRequestHandler<::test::typesinprotocols::Protocol>; |
| static inline fidl::InterfaceRequestHandler<::test::typesinprotocols::Protocol> Convert(fidl::ProtocolHandler<::test_typesinprotocols::Protocol>&& c) { |
| return [c = std::move(c)](fidl::InterfaceRequest<::test::typesinprotocols::Protocol> r) { |
| c(::fidl::HLCPPToNatural(r)); |
| }; |
| } |
| }; |
| |
| template <> |
| struct HLCPPToNaturalTraits<fidl::InterfaceRequestHandler<::test::typesinprotocols::Protocol>> { |
| using NaturalType = fidl::ProtocolHandler<::test_typesinprotocols::Protocol>; |
| static inline fidl::ProtocolHandler<::test_typesinprotocols::Protocol> Convert(fidl::InterfaceRequestHandler<::test::typesinprotocols::Protocol>&& c) { |
| return [c = std::move(c)](fidl::ServerEnd<::test_typesinprotocols::Protocol> r) { |
| c(::fidl::NaturalToHLCPP(r)); |
| }; |
| } |
| }; |
| |
| template <> |
| struct NaturalToHLCPPTraits<::test_typesinprotocols::Struct> { |
| using HLCPPType = ::test::typesinprotocols::Struct; |
| static inline ::test::typesinprotocols::Struct Convert(::test_typesinprotocols::Struct&&); |
| }; |
| template <> |
| struct HLCPPToNaturalTraits<::test::typesinprotocols::Struct> { |
| using NaturalType = ::test_typesinprotocols::Struct; |
| static inline ::test_typesinprotocols::Struct Convert(::test::typesinprotocols::Struct&&); |
| }; |
| template <> |
| struct NaturalToHLCPPTraits<::test_typesinprotocols::ResourceStruct> { |
| using HLCPPType = ::test::typesinprotocols::ResourceStruct; |
| static inline ::test::typesinprotocols::ResourceStruct Convert(::test_typesinprotocols::ResourceStruct&&); |
| }; |
| template <> |
| struct HLCPPToNaturalTraits<::test::typesinprotocols::ResourceStruct> { |
| using NaturalType = ::test_typesinprotocols::ResourceStruct; |
| static inline ::test_typesinprotocols::ResourceStruct Convert(::test::typesinprotocols::ResourceStruct&&); |
| }; |
| template <> |
| struct NaturalToHLCPPTraits<::test_typesinprotocols::Basic> { |
| using HLCPPType = ::test::typesinprotocols::Basic; |
| static inline ::test::typesinprotocols::Basic Convert(::test_typesinprotocols::Basic&&); |
| }; |
| template <> |
| struct HLCPPToNaturalTraits<::test::typesinprotocols::Basic> { |
| using NaturalType = ::test_typesinprotocols::Basic; |
| static inline ::test_typesinprotocols::Basic Convert(::test::typesinprotocols::Basic&&); |
| }; |
| template <> |
| struct NaturalToHLCPPTraits<::test_typesinprotocols::Compound> { |
| using HLCPPType = ::test::typesinprotocols::Compound; |
| static inline ::test::typesinprotocols::Compound Convert(::test_typesinprotocols::Compound&&); |
| }; |
| template <> |
| struct HLCPPToNaturalTraits<::test::typesinprotocols::Compound> { |
| using NaturalType = ::test_typesinprotocols::Compound; |
| static inline ::test_typesinprotocols::Compound Convert(::test::typesinprotocols::Compound&&); |
| }; |
| template <> |
| struct NaturalToHLCPPTraits<::test_typesinprotocols::ArrayBasic> { |
| using HLCPPType = ::test::typesinprotocols::ArrayBasic; |
| static inline ::test::typesinprotocols::ArrayBasic Convert(::test_typesinprotocols::ArrayBasic&&); |
| }; |
| template <> |
| struct HLCPPToNaturalTraits<::test::typesinprotocols::ArrayBasic> { |
| using NaturalType = ::test_typesinprotocols::ArrayBasic; |
| static inline ::test_typesinprotocols::ArrayBasic Convert(::test::typesinprotocols::ArrayBasic&&); |
| }; |
| template <> |
| struct NaturalToHLCPPTraits<::test_typesinprotocols::ArrayCompound> { |
| using HLCPPType = ::test::typesinprotocols::ArrayCompound; |
| static inline ::test::typesinprotocols::ArrayCompound Convert(::test_typesinprotocols::ArrayCompound&&); |
| }; |
| template <> |
| struct HLCPPToNaturalTraits<::test::typesinprotocols::ArrayCompound> { |
| using NaturalType = ::test_typesinprotocols::ArrayCompound; |
| static inline ::test_typesinprotocols::ArrayCompound Convert(::test::typesinprotocols::ArrayCompound&&); |
| }; |
| template <> |
| struct NaturalToHLCPPTraits<::test_typesinprotocols::VectorBasic> { |
| using HLCPPType = ::test::typesinprotocols::VectorBasic; |
| static inline ::test::typesinprotocols::VectorBasic Convert(::test_typesinprotocols::VectorBasic&&); |
| }; |
| template <> |
| struct HLCPPToNaturalTraits<::test::typesinprotocols::VectorBasic> { |
| using NaturalType = ::test_typesinprotocols::VectorBasic; |
| static inline ::test_typesinprotocols::VectorBasic Convert(::test::typesinprotocols::VectorBasic&&); |
| }; |
| template <> |
| struct NaturalToHLCPPTraits<::test_typesinprotocols::VectorCompound> { |
| using HLCPPType = ::test::typesinprotocols::VectorCompound; |
| static inline ::test::typesinprotocols::VectorCompound Convert(::test_typesinprotocols::VectorCompound&&); |
| }; |
| template <> |
| struct HLCPPToNaturalTraits<::test::typesinprotocols::VectorCompound> { |
| using NaturalType = ::test_typesinprotocols::VectorCompound; |
| static inline ::test_typesinprotocols::VectorCompound Convert(::test::typesinprotocols::VectorCompound&&); |
| }; |
| template <> |
| struct NaturalToHLCPPTraits<::test_typesinprotocols::VectorOptional> { |
| using HLCPPType = ::test::typesinprotocols::VectorOptional; |
| static inline ::test::typesinprotocols::VectorOptional Convert(::test_typesinprotocols::VectorOptional&&); |
| }; |
| template <> |
| struct HLCPPToNaturalTraits<::test::typesinprotocols::VectorOptional> { |
| using NaturalType = ::test_typesinprotocols::VectorOptional; |
| static inline ::test_typesinprotocols::VectorOptional Convert(::test::typesinprotocols::VectorOptional&&); |
| }; |
| template <> |
| struct NaturalToHLCPPTraits<::test_typesinprotocols::ArrayVectorNested> { |
| using HLCPPType = ::test::typesinprotocols::ArrayVectorNested; |
| static inline ::test::typesinprotocols::ArrayVectorNested Convert(::test_typesinprotocols::ArrayVectorNested&&); |
| }; |
| template <> |
| struct HLCPPToNaturalTraits<::test::typesinprotocols::ArrayVectorNested> { |
| using NaturalType = ::test_typesinprotocols::ArrayVectorNested; |
| static inline ::test_typesinprotocols::ArrayVectorNested Convert(::test::typesinprotocols::ArrayVectorNested&&); |
| }; |
| template <> |
| struct NaturalToHLCPPTraits<::test_typesinprotocols::Resource> { |
| using HLCPPType = ::test::typesinprotocols::Resource; |
| static inline ::test::typesinprotocols::Resource Convert(::test_typesinprotocols::Resource&&); |
| }; |
| template <> |
| struct HLCPPToNaturalTraits<::test::typesinprotocols::Resource> { |
| using NaturalType = ::test_typesinprotocols::Resource; |
| static inline ::test_typesinprotocols::Resource Convert(::test::typesinprotocols::Resource&&); |
| }; |
| template <> |
| struct NaturalToHLCPPTraits<::test_typesinprotocols::Table> { |
| using HLCPPType = ::test::typesinprotocols::Table; |
| static inline ::test::typesinprotocols::Table Convert(::test_typesinprotocols::Table&&); |
| }; |
| template <> |
| struct HLCPPToNaturalTraits<::test::typesinprotocols::Table> { |
| using NaturalType = ::test_typesinprotocols::Table; |
| static inline ::test_typesinprotocols::Table Convert(::test::typesinprotocols::Table&&); |
| }; |
| template <> |
| struct NaturalToHLCPPTraits<::test_typesinprotocols::ResourceTable> { |
| using HLCPPType = ::test::typesinprotocols::ResourceTable; |
| static inline ::test::typesinprotocols::ResourceTable Convert(::test_typesinprotocols::ResourceTable&&); |
| }; |
| template <> |
| struct HLCPPToNaturalTraits<::test::typesinprotocols::ResourceTable> { |
| using NaturalType = ::test_typesinprotocols::ResourceTable; |
| static inline ::test_typesinprotocols::ResourceTable Convert(::test::typesinprotocols::ResourceTable&&); |
| }; |
| template <> |
| struct NaturalToHLCPPTraits<::test_typesinprotocols::Union> { |
| using HLCPPType = ::test::typesinprotocols::Union; |
| static inline ::test::typesinprotocols::Union Convert(::test_typesinprotocols::Union&&); |
| }; |
| template <> |
| struct HLCPPToNaturalTraits<::test::typesinprotocols::Union> { |
| using NaturalType = ::test_typesinprotocols::Union; |
| static inline ::test_typesinprotocols::Union Convert(::test::typesinprotocols::Union&&); |
| }; |
| template <> |
| struct NaturalToHLCPPTraits<::test_typesinprotocols::ResourceUnion> { |
| using HLCPPType = ::test::typesinprotocols::ResourceUnion; |
| static inline ::test::typesinprotocols::ResourceUnion Convert(::test_typesinprotocols::ResourceUnion&&); |
| }; |
| template <> |
| struct HLCPPToNaturalTraits<::test::typesinprotocols::ResourceUnion> { |
| using NaturalType = ::test_typesinprotocols::ResourceUnion; |
| static inline ::test_typesinprotocols::ResourceUnion Convert(::test::typesinprotocols::ResourceUnion&&); |
| }; |
| template <> |
| struct NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorBasicResult> { |
| using HLCPPType = ::test::typesinprotocols::Protocol_ErrorBasic_Result; |
| static inline ::test::typesinprotocols::Protocol_ErrorBasic_Result Convert(::test_typesinprotocols::ProtocolErrorBasicResult&&); |
| }; |
| template <> |
| struct HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorBasic_Result> { |
| using NaturalType = ::test_typesinprotocols::ProtocolErrorBasicResult; |
| static inline ::test_typesinprotocols::ProtocolErrorBasicResult Convert(::test::typesinprotocols::Protocol_ErrorBasic_Result&&); |
| }; |
| template <> |
| struct NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorCompoundResult> { |
| using HLCPPType = ::test::typesinprotocols::Protocol_ErrorCompound_Result; |
| static inline ::test::typesinprotocols::Protocol_ErrorCompound_Result Convert(::test_typesinprotocols::ProtocolErrorCompoundResult&&); |
| }; |
| template <> |
| struct HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorCompound_Result> { |
| using NaturalType = ::test_typesinprotocols::ProtocolErrorCompoundResult; |
| static inline ::test_typesinprotocols::ProtocolErrorCompoundResult Convert(::test::typesinprotocols::Protocol_ErrorCompound_Result&&); |
| }; |
| template <> |
| struct NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorArrayBasicResult> { |
| using HLCPPType = ::test::typesinprotocols::Protocol_ErrorArrayBasic_Result; |
| static inline ::test::typesinprotocols::Protocol_ErrorArrayBasic_Result Convert(::test_typesinprotocols::ProtocolErrorArrayBasicResult&&); |
| }; |
| template <> |
| struct HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorArrayBasic_Result> { |
| using NaturalType = ::test_typesinprotocols::ProtocolErrorArrayBasicResult; |
| static inline ::test_typesinprotocols::ProtocolErrorArrayBasicResult Convert(::test::typesinprotocols::Protocol_ErrorArrayBasic_Result&&); |
| }; |
| template <> |
| struct NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorArrayCompoundResult> { |
| using HLCPPType = ::test::typesinprotocols::Protocol_ErrorArrayCompound_Result; |
| static inline ::test::typesinprotocols::Protocol_ErrorArrayCompound_Result Convert(::test_typesinprotocols::ProtocolErrorArrayCompoundResult&&); |
| }; |
| template <> |
| struct HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorArrayCompound_Result> { |
| using NaturalType = ::test_typesinprotocols::ProtocolErrorArrayCompoundResult; |
| static inline ::test_typesinprotocols::ProtocolErrorArrayCompoundResult Convert(::test::typesinprotocols::Protocol_ErrorArrayCompound_Result&&); |
| }; |
| template <> |
| struct NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorVectorBasicResult> { |
| using HLCPPType = ::test::typesinprotocols::Protocol_ErrorVectorBasic_Result; |
| static inline ::test::typesinprotocols::Protocol_ErrorVectorBasic_Result Convert(::test_typesinprotocols::ProtocolErrorVectorBasicResult&&); |
| }; |
| template <> |
| struct HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorVectorBasic_Result> { |
| using NaturalType = ::test_typesinprotocols::ProtocolErrorVectorBasicResult; |
| static inline ::test_typesinprotocols::ProtocolErrorVectorBasicResult Convert(::test::typesinprotocols::Protocol_ErrorVectorBasic_Result&&); |
| }; |
| template <> |
| struct NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorVectorCompoundResult> { |
| using HLCPPType = ::test::typesinprotocols::Protocol_ErrorVectorCompound_Result; |
| static inline ::test::typesinprotocols::Protocol_ErrorVectorCompound_Result Convert(::test_typesinprotocols::ProtocolErrorVectorCompoundResult&&); |
| }; |
| template <> |
| struct HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorVectorCompound_Result> { |
| using NaturalType = ::test_typesinprotocols::ProtocolErrorVectorCompoundResult; |
| static inline ::test_typesinprotocols::ProtocolErrorVectorCompoundResult Convert(::test::typesinprotocols::Protocol_ErrorVectorCompound_Result&&); |
| }; |
| template <> |
| struct NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorVectorOptionalResult> { |
| using HLCPPType = ::test::typesinprotocols::Protocol_ErrorVectorOptional_Result; |
| static inline ::test::typesinprotocols::Protocol_ErrorVectorOptional_Result Convert(::test_typesinprotocols::ProtocolErrorVectorOptionalResult&&); |
| }; |
| template <> |
| struct HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorVectorOptional_Result> { |
| using NaturalType = ::test_typesinprotocols::ProtocolErrorVectorOptionalResult; |
| static inline ::test_typesinprotocols::ProtocolErrorVectorOptionalResult Convert(::test::typesinprotocols::Protocol_ErrorVectorOptional_Result&&); |
| }; |
| template <> |
| struct NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorArrayVectorNestedResult> { |
| using HLCPPType = ::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result; |
| static inline ::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result Convert(::test_typesinprotocols::ProtocolErrorArrayVectorNestedResult&&); |
| }; |
| template <> |
| struct HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result> { |
| using NaturalType = ::test_typesinprotocols::ProtocolErrorArrayVectorNestedResult; |
| static inline ::test_typesinprotocols::ProtocolErrorArrayVectorNestedResult Convert(::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result&&); |
| }; |
| template <> |
| struct NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorResourceResult> { |
| using HLCPPType = ::test::typesinprotocols::Protocol_ErrorResource_Result; |
| static inline ::test::typesinprotocols::Protocol_ErrorResource_Result Convert(::test_typesinprotocols::ProtocolErrorResourceResult&&); |
| }; |
| template <> |
| struct HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorResource_Result> { |
| using NaturalType = ::test_typesinprotocols::ProtocolErrorResourceResult; |
| static inline ::test_typesinprotocols::ProtocolErrorResourceResult Convert(::test::typesinprotocols::Protocol_ErrorResource_Result&&); |
| }; |
| |
| ::test::typesinprotocols::Struct NaturalToHLCPPTraits<::test_typesinprotocols::Struct>::Convert(::test_typesinprotocols::Struct&& value) { |
| ::test::typesinprotocols::Struct hlcpp; |
| hlcpp.__reserved = ::fidl::NaturalToHLCPP(std::move(value.__reserved())); |
| return hlcpp; |
| } |
| |
| ::test_typesinprotocols::Struct HLCPPToNaturalTraits<::test::typesinprotocols::Struct>::Convert(::test::typesinprotocols::Struct&& value) { |
| return ::test_typesinprotocols::Struct{{ |
| .__reserved = ::fidl::HLCPPToNatural(std::move(value.__reserved)), |
| }}; |
| } |
| ::test::typesinprotocols::ResourceStruct NaturalToHLCPPTraits<::test_typesinprotocols::ResourceStruct>::Convert(::test_typesinprotocols::ResourceStruct&& value) { |
| ::test::typesinprotocols::ResourceStruct hlcpp; |
| hlcpp.__reserved = ::fidl::NaturalToHLCPP(std::move(value.__reserved())); |
| return hlcpp; |
| } |
| |
| ::test_typesinprotocols::ResourceStruct HLCPPToNaturalTraits<::test::typesinprotocols::ResourceStruct>::Convert(::test::typesinprotocols::ResourceStruct&& value) { |
| return ::test_typesinprotocols::ResourceStruct{{ |
| .__reserved = ::fidl::HLCPPToNatural(std::move(value.__reserved)), |
| }}; |
| } |
| ::test::typesinprotocols::Basic NaturalToHLCPPTraits<::test_typesinprotocols::Basic>::Convert(::test_typesinprotocols::Basic&& value) { |
| ::test::typesinprotocols::Basic hlcpp; |
| hlcpp.uint8 = ::fidl::NaturalToHLCPP(std::move(value.uint8())); |
| hlcpp.uint16 = ::fidl::NaturalToHLCPP(std::move(value.uint16())); |
| hlcpp.uint32 = ::fidl::NaturalToHLCPP(std::move(value.uint32())); |
| hlcpp.uint64 = ::fidl::NaturalToHLCPP(std::move(value.uint64())); |
| hlcpp.int8 = ::fidl::NaturalToHLCPP(std::move(value.int8())); |
| hlcpp.int16 = ::fidl::NaturalToHLCPP(std::move(value.int16())); |
| hlcpp.int32 = ::fidl::NaturalToHLCPP(std::move(value.int32())); |
| hlcpp.int64 = ::fidl::NaturalToHLCPP(std::move(value.int64())); |
| hlcpp.float32 = ::fidl::NaturalToHLCPP(std::move(value.float32())); |
| hlcpp.float64 = ::fidl::NaturalToHLCPP(std::move(value.float64())); |
| hlcpp.string = ::fidl::NaturalToHLCPP(std::move(value.string())); |
| hlcpp.opt_string = ::fidl::NaturalToHLCPP(std::move(value.opt_string())); |
| return hlcpp; |
| } |
| |
| ::test_typesinprotocols::Basic HLCPPToNaturalTraits<::test::typesinprotocols::Basic>::Convert(::test::typesinprotocols::Basic&& value) { |
| return ::test_typesinprotocols::Basic{{ |
| .uint8 = ::fidl::HLCPPToNatural(std::move(value.uint8)), |
| .uint16 = ::fidl::HLCPPToNatural(std::move(value.uint16)), |
| .uint32 = ::fidl::HLCPPToNatural(std::move(value.uint32)), |
| .uint64 = ::fidl::HLCPPToNatural(std::move(value.uint64)), |
| .int8 = ::fidl::HLCPPToNatural(std::move(value.int8)), |
| .int16 = ::fidl::HLCPPToNatural(std::move(value.int16)), |
| .int32 = ::fidl::HLCPPToNatural(std::move(value.int32)), |
| .int64 = ::fidl::HLCPPToNatural(std::move(value.int64)), |
| .float32 = ::fidl::HLCPPToNatural(std::move(value.float32)), |
| .float64 = ::fidl::HLCPPToNatural(std::move(value.float64)), |
| .string = ::fidl::HLCPPToNatural(std::move(value.string)), |
| .opt_string = ::fidl::HLCPPToNatural(std::move(value.opt_string)), |
| }}; |
| } |
| ::test::typesinprotocols::Compound NaturalToHLCPPTraits<::test_typesinprotocols::Compound>::Convert(::test_typesinprotocols::Compound&& value) { |
| ::test::typesinprotocols::Compound hlcpp; |
| hlcpp.bits = ::fidl::NaturalToHLCPP(std::move(value.bits())); |
| hlcpp.enum_ = ::fidl::NaturalToHLCPP(std::move(value.enum_())); |
| hlcpp.struct_ = ::fidl::NaturalToHLCPP(std::move(value.struct_())); |
| hlcpp.table = ::fidl::NaturalToHLCPP(std::move(value.table())); |
| hlcpp.union_ = ::fidl::NaturalToHLCPP(std::move(value.union_())); |
| hlcpp.opt_struct = ::fidl::NaturalToHLCPP(std::move(value.opt_struct())); |
| hlcpp.opt_union = ::fidl::NaturalToHLCPP(std::move(value.opt_union())); |
| return hlcpp; |
| } |
| |
| ::test_typesinprotocols::Compound HLCPPToNaturalTraits<::test::typesinprotocols::Compound>::Convert(::test::typesinprotocols::Compound&& value) { |
| return ::test_typesinprotocols::Compound{{ |
| .bits = ::fidl::HLCPPToNatural(std::move(value.bits)), |
| .enum_ = ::fidl::HLCPPToNatural(std::move(value.enum_)), |
| .struct_ = ::fidl::HLCPPToNatural(std::move(value.struct_)), |
| .table = ::fidl::HLCPPToNatural(std::move(value.table)), |
| .union_ = ::fidl::HLCPPToNatural(std::move(value.union_)), |
| .opt_struct = ::fidl::HLCPPToNatural(std::move(value.opt_struct)), |
| .opt_union = ::fidl::HLCPPToNatural(std::move(value.opt_union)), |
| }}; |
| } |
| ::test::typesinprotocols::ArrayBasic NaturalToHLCPPTraits<::test_typesinprotocols::ArrayBasic>::Convert(::test_typesinprotocols::ArrayBasic&& value) { |
| ::test::typesinprotocols::ArrayBasic hlcpp; |
| hlcpp.array_uint8 = ::fidl::NaturalToHLCPP(std::move(value.array_uint8())); |
| hlcpp.array_uint16 = ::fidl::NaturalToHLCPP(std::move(value.array_uint16())); |
| hlcpp.array_uint32 = ::fidl::NaturalToHLCPP(std::move(value.array_uint32())); |
| hlcpp.array_uint64 = ::fidl::NaturalToHLCPP(std::move(value.array_uint64())); |
| hlcpp.array_int8 = ::fidl::NaturalToHLCPP(std::move(value.array_int8())); |
| hlcpp.array_int16 = ::fidl::NaturalToHLCPP(std::move(value.array_int16())); |
| hlcpp.array_int32 = ::fidl::NaturalToHLCPP(std::move(value.array_int32())); |
| hlcpp.array_int64 = ::fidl::NaturalToHLCPP(std::move(value.array_int64())); |
| hlcpp.array_float32 = ::fidl::NaturalToHLCPP(std::move(value.array_float32())); |
| hlcpp.array_float64 = ::fidl::NaturalToHLCPP(std::move(value.array_float64())); |
| hlcpp.array_string = ::fidl::NaturalToHLCPP(std::move(value.array_string())); |
| hlcpp.array_opt_string = ::fidl::NaturalToHLCPP(std::move(value.array_opt_string())); |
| return hlcpp; |
| } |
| |
| ::test_typesinprotocols::ArrayBasic HLCPPToNaturalTraits<::test::typesinprotocols::ArrayBasic>::Convert(::test::typesinprotocols::ArrayBasic&& value) { |
| return ::test_typesinprotocols::ArrayBasic{{ |
| .array_uint8 = ::fidl::HLCPPToNatural(std::move(value.array_uint8)), |
| .array_uint16 = ::fidl::HLCPPToNatural(std::move(value.array_uint16)), |
| .array_uint32 = ::fidl::HLCPPToNatural(std::move(value.array_uint32)), |
| .array_uint64 = ::fidl::HLCPPToNatural(std::move(value.array_uint64)), |
| .array_int8 = ::fidl::HLCPPToNatural(std::move(value.array_int8)), |
| .array_int16 = ::fidl::HLCPPToNatural(std::move(value.array_int16)), |
| .array_int32 = ::fidl::HLCPPToNatural(std::move(value.array_int32)), |
| .array_int64 = ::fidl::HLCPPToNatural(std::move(value.array_int64)), |
| .array_float32 = ::fidl::HLCPPToNatural(std::move(value.array_float32)), |
| .array_float64 = ::fidl::HLCPPToNatural(std::move(value.array_float64)), |
| .array_string = ::fidl::HLCPPToNatural(std::move(value.array_string)), |
| .array_opt_string = ::fidl::HLCPPToNatural(std::move(value.array_opt_string)), |
| }}; |
| } |
| ::test::typesinprotocols::ArrayCompound NaturalToHLCPPTraits<::test_typesinprotocols::ArrayCompound>::Convert(::test_typesinprotocols::ArrayCompound&& value) { |
| ::test::typesinprotocols::ArrayCompound hlcpp; |
| hlcpp.array_bits = ::fidl::NaturalToHLCPP(std::move(value.array_bits())); |
| hlcpp.array_enum = ::fidl::NaturalToHLCPP(std::move(value.array_enum())); |
| hlcpp.array_struct = ::fidl::NaturalToHLCPP(std::move(value.array_struct())); |
| hlcpp.array_table = ::fidl::NaturalToHLCPP(std::move(value.array_table())); |
| hlcpp.array_union = ::fidl::NaturalToHLCPP(std::move(value.array_union())); |
| hlcpp.array_opt_struct = ::fidl::NaturalToHLCPP(std::move(value.array_opt_struct())); |
| hlcpp.array_opt_union = ::fidl::NaturalToHLCPP(std::move(value.array_opt_union())); |
| return hlcpp; |
| } |
| |
| ::test_typesinprotocols::ArrayCompound HLCPPToNaturalTraits<::test::typesinprotocols::ArrayCompound>::Convert(::test::typesinprotocols::ArrayCompound&& value) { |
| return ::test_typesinprotocols::ArrayCompound{{ |
| .array_bits = ::fidl::HLCPPToNatural(std::move(value.array_bits)), |
| .array_enum = ::fidl::HLCPPToNatural(std::move(value.array_enum)), |
| .array_struct = ::fidl::HLCPPToNatural(std::move(value.array_struct)), |
| .array_table = ::fidl::HLCPPToNatural(std::move(value.array_table)), |
| .array_union = ::fidl::HLCPPToNatural(std::move(value.array_union)), |
| .array_opt_struct = ::fidl::HLCPPToNatural(std::move(value.array_opt_struct)), |
| .array_opt_union = ::fidl::HLCPPToNatural(std::move(value.array_opt_union)), |
| }}; |
| } |
| ::test::typesinprotocols::VectorBasic NaturalToHLCPPTraits<::test_typesinprotocols::VectorBasic>::Convert(::test_typesinprotocols::VectorBasic&& value) { |
| ::test::typesinprotocols::VectorBasic hlcpp; |
| hlcpp.vector_uint8 = ::fidl::NaturalToHLCPP(std::move(value.vector_uint8())); |
| hlcpp.vector_uint16 = ::fidl::NaturalToHLCPP(std::move(value.vector_uint16())); |
| hlcpp.vector_uint32 = ::fidl::NaturalToHLCPP(std::move(value.vector_uint32())); |
| hlcpp.vector_uint64 = ::fidl::NaturalToHLCPP(std::move(value.vector_uint64())); |
| hlcpp.vector_int8 = ::fidl::NaturalToHLCPP(std::move(value.vector_int8())); |
| hlcpp.vector_int16 = ::fidl::NaturalToHLCPP(std::move(value.vector_int16())); |
| hlcpp.vector_int32 = ::fidl::NaturalToHLCPP(std::move(value.vector_int32())); |
| hlcpp.vector_int64 = ::fidl::NaturalToHLCPP(std::move(value.vector_int64())); |
| hlcpp.vector_float32 = ::fidl::NaturalToHLCPP(std::move(value.vector_float32())); |
| hlcpp.vector_float64 = ::fidl::NaturalToHLCPP(std::move(value.vector_float64())); |
| hlcpp.vector_string = ::fidl::NaturalToHLCPP(std::move(value.vector_string())); |
| hlcpp.vector_opt_string = ::fidl::NaturalToHLCPP(std::move(value.vector_opt_string())); |
| return hlcpp; |
| } |
| |
| ::test_typesinprotocols::VectorBasic HLCPPToNaturalTraits<::test::typesinprotocols::VectorBasic>::Convert(::test::typesinprotocols::VectorBasic&& value) { |
| return ::test_typesinprotocols::VectorBasic{{ |
| .vector_uint8 = ::fidl::HLCPPToNatural(std::move(value.vector_uint8)), |
| .vector_uint16 = ::fidl::HLCPPToNatural(std::move(value.vector_uint16)), |
| .vector_uint32 = ::fidl::HLCPPToNatural(std::move(value.vector_uint32)), |
| .vector_uint64 = ::fidl::HLCPPToNatural(std::move(value.vector_uint64)), |
| .vector_int8 = ::fidl::HLCPPToNatural(std::move(value.vector_int8)), |
| .vector_int16 = ::fidl::HLCPPToNatural(std::move(value.vector_int16)), |
| .vector_int32 = ::fidl::HLCPPToNatural(std::move(value.vector_int32)), |
| .vector_int64 = ::fidl::HLCPPToNatural(std::move(value.vector_int64)), |
| .vector_float32 = ::fidl::HLCPPToNatural(std::move(value.vector_float32)), |
| .vector_float64 = ::fidl::HLCPPToNatural(std::move(value.vector_float64)), |
| .vector_string = ::fidl::HLCPPToNatural(std::move(value.vector_string)), |
| .vector_opt_string = ::fidl::HLCPPToNatural(std::move(value.vector_opt_string)), |
| }}; |
| } |
| ::test::typesinprotocols::VectorCompound NaturalToHLCPPTraits<::test_typesinprotocols::VectorCompound>::Convert(::test_typesinprotocols::VectorCompound&& value) { |
| ::test::typesinprotocols::VectorCompound hlcpp; |
| hlcpp.vector_bits = ::fidl::NaturalToHLCPP(std::move(value.vector_bits())); |
| hlcpp.vector_enum = ::fidl::NaturalToHLCPP(std::move(value.vector_enum())); |
| hlcpp.vector_struct = ::fidl::NaturalToHLCPP(std::move(value.vector_struct())); |
| hlcpp.vector_table = ::fidl::NaturalToHLCPP(std::move(value.vector_table())); |
| hlcpp.vector_union = ::fidl::NaturalToHLCPP(std::move(value.vector_union())); |
| hlcpp.vector_opt_struct = ::fidl::NaturalToHLCPP(std::move(value.vector_opt_struct())); |
| hlcpp.vector_opt_union = ::fidl::NaturalToHLCPP(std::move(value.vector_opt_union())); |
| return hlcpp; |
| } |
| |
| ::test_typesinprotocols::VectorCompound HLCPPToNaturalTraits<::test::typesinprotocols::VectorCompound>::Convert(::test::typesinprotocols::VectorCompound&& value) { |
| return ::test_typesinprotocols::VectorCompound{{ |
| .vector_bits = ::fidl::HLCPPToNatural(std::move(value.vector_bits)), |
| .vector_enum = ::fidl::HLCPPToNatural(std::move(value.vector_enum)), |
| .vector_struct = ::fidl::HLCPPToNatural(std::move(value.vector_struct)), |
| .vector_table = ::fidl::HLCPPToNatural(std::move(value.vector_table)), |
| .vector_union = ::fidl::HLCPPToNatural(std::move(value.vector_union)), |
| .vector_opt_struct = ::fidl::HLCPPToNatural(std::move(value.vector_opt_struct)), |
| .vector_opt_union = ::fidl::HLCPPToNatural(std::move(value.vector_opt_union)), |
| }}; |
| } |
| ::test::typesinprotocols::VectorOptional NaturalToHLCPPTraits<::test_typesinprotocols::VectorOptional>::Convert(::test_typesinprotocols::VectorOptional&& value) { |
| ::test::typesinprotocols::VectorOptional hlcpp; |
| hlcpp.opt_vector_uint8 = ::fidl::NaturalToHLCPP(std::move(value.opt_vector_uint8())); |
| hlcpp.opt_vector_string = ::fidl::NaturalToHLCPP(std::move(value.opt_vector_string())); |
| hlcpp.opt_vector_struct = ::fidl::NaturalToHLCPP(std::move(value.opt_vector_struct())); |
| hlcpp.opt_vector_opt_struct = ::fidl::NaturalToHLCPP(std::move(value.opt_vector_opt_struct())); |
| return hlcpp; |
| } |
| |
| ::test_typesinprotocols::VectorOptional HLCPPToNaturalTraits<::test::typesinprotocols::VectorOptional>::Convert(::test::typesinprotocols::VectorOptional&& value) { |
| return ::test_typesinprotocols::VectorOptional{{ |
| .opt_vector_uint8 = ::fidl::HLCPPToNatural(std::move(value.opt_vector_uint8)), |
| .opt_vector_string = ::fidl::HLCPPToNatural(std::move(value.opt_vector_string)), |
| .opt_vector_struct = ::fidl::HLCPPToNatural(std::move(value.opt_vector_struct)), |
| .opt_vector_opt_struct = ::fidl::HLCPPToNatural(std::move(value.opt_vector_opt_struct)), |
| }}; |
| } |
| ::test::typesinprotocols::ArrayVectorNested NaturalToHLCPPTraits<::test_typesinprotocols::ArrayVectorNested>::Convert(::test_typesinprotocols::ArrayVectorNested&& value) { |
| ::test::typesinprotocols::ArrayVectorNested hlcpp; |
| hlcpp.array_array_uint8 = ::fidl::NaturalToHLCPP(std::move(value.array_array_uint8())); |
| hlcpp.array_vector_uint8 = ::fidl::NaturalToHLCPP(std::move(value.array_vector_uint8())); |
| hlcpp.vector_array_uint8 = ::fidl::NaturalToHLCPP(std::move(value.vector_array_uint8())); |
| hlcpp.vector_vector_uint8 = ::fidl::NaturalToHLCPP(std::move(value.vector_vector_uint8())); |
| return hlcpp; |
| } |
| |
| ::test_typesinprotocols::ArrayVectorNested HLCPPToNaturalTraits<::test::typesinprotocols::ArrayVectorNested>::Convert(::test::typesinprotocols::ArrayVectorNested&& value) { |
| return ::test_typesinprotocols::ArrayVectorNested{{ |
| .array_array_uint8 = ::fidl::HLCPPToNatural(std::move(value.array_array_uint8)), |
| .array_vector_uint8 = ::fidl::HLCPPToNatural(std::move(value.array_vector_uint8)), |
| .vector_array_uint8 = ::fidl::HLCPPToNatural(std::move(value.vector_array_uint8)), |
| .vector_vector_uint8 = ::fidl::HLCPPToNatural(std::move(value.vector_vector_uint8)), |
| }}; |
| } |
| ::test::typesinprotocols::Resource NaturalToHLCPPTraits<::test_typesinprotocols::Resource>::Convert(::test_typesinprotocols::Resource&& value) { |
| ::test::typesinprotocols::Resource hlcpp; |
| hlcpp.handle = ::fidl::NaturalToHLCPP(std::move(value.handle())); |
| hlcpp.vmo = ::fidl::NaturalToHLCPP(std::move(value.vmo())); |
| hlcpp.client_end = ::fidl::NaturalToHLCPP(std::move(value.client_end())); |
| hlcpp.server_end = ::fidl::NaturalToHLCPP(std::move(value.server_end())); |
| hlcpp.struct_ = ::fidl::NaturalToHLCPP(std::move(value.struct_())); |
| hlcpp.table = ::fidl::NaturalToHLCPP(std::move(value.table())); |
| hlcpp.union_ = ::fidl::NaturalToHLCPP(std::move(value.union_())); |
| hlcpp.opt_handle = ::fidl::NaturalToHLCPP(std::move(value.opt_handle())); |
| hlcpp.opt_vmo = ::fidl::NaturalToHLCPP(std::move(value.opt_vmo())); |
| hlcpp.opt_client_end = ::fidl::NaturalToHLCPP(std::move(value.opt_client_end())); |
| hlcpp.opt_server_end = ::fidl::NaturalToHLCPP(std::move(value.opt_server_end())); |
| hlcpp.opt_struct = ::fidl::NaturalToHLCPP(std::move(value.opt_struct())); |
| hlcpp.opt_union = ::fidl::NaturalToHLCPP(std::move(value.opt_union())); |
| hlcpp.array_handle = ::fidl::NaturalToHLCPP(std::move(value.array_handle())); |
| hlcpp.array_vmo = ::fidl::NaturalToHLCPP(std::move(value.array_vmo())); |
| hlcpp.array_client_end = ::fidl::NaturalToHLCPP(std::move(value.array_client_end())); |
| hlcpp.array_server_end = ::fidl::NaturalToHLCPP(std::move(value.array_server_end())); |
| hlcpp.array_struct = ::fidl::NaturalToHLCPP(std::move(value.array_struct())); |
| hlcpp.array_table = ::fidl::NaturalToHLCPP(std::move(value.array_table())); |
| hlcpp.array_union = ::fidl::NaturalToHLCPP(std::move(value.array_union())); |
| hlcpp.vector_handle = ::fidl::NaturalToHLCPP(std::move(value.vector_handle())); |
| hlcpp.vector_vmo = ::fidl::NaturalToHLCPP(std::move(value.vector_vmo())); |
| hlcpp.vector_client_end = ::fidl::NaturalToHLCPP(std::move(value.vector_client_end())); |
| hlcpp.vector_server_end = ::fidl::NaturalToHLCPP(std::move(value.vector_server_end())); |
| hlcpp.vector_struct = ::fidl::NaturalToHLCPP(std::move(value.vector_struct())); |
| hlcpp.vector_table = ::fidl::NaturalToHLCPP(std::move(value.vector_table())); |
| hlcpp.vector_union = ::fidl::NaturalToHLCPP(std::move(value.vector_union())); |
| return hlcpp; |
| } |
| |
| ::test_typesinprotocols::Resource HLCPPToNaturalTraits<::test::typesinprotocols::Resource>::Convert(::test::typesinprotocols::Resource&& value) { |
| return ::test_typesinprotocols::Resource{{ |
| .handle = ::fidl::HLCPPToNatural(std::move(value.handle)), |
| .vmo = ::fidl::HLCPPToNatural(std::move(value.vmo)), |
| .client_end = ::fidl::HLCPPToNatural(std::move(value.client_end)), |
| .server_end = ::fidl::HLCPPToNatural(std::move(value.server_end)), |
| .struct_ = ::fidl::HLCPPToNatural(std::move(value.struct_)), |
| .table = ::fidl::HLCPPToNatural(std::move(value.table)), |
| .union_ = ::fidl::HLCPPToNatural(std::move(value.union_)), |
| .opt_handle = ::fidl::HLCPPToNatural(std::move(value.opt_handle)), |
| .opt_vmo = ::fidl::HLCPPToNatural(std::move(value.opt_vmo)), |
| .opt_client_end = ::fidl::HLCPPToNatural(std::move(value.opt_client_end)), |
| .opt_server_end = ::fidl::HLCPPToNatural(std::move(value.opt_server_end)), |
| .opt_struct = ::fidl::HLCPPToNatural(std::move(value.opt_struct)), |
| .opt_union = ::fidl::HLCPPToNatural(std::move(value.opt_union)), |
| .array_handle = ::fidl::HLCPPToNatural(std::move(value.array_handle)), |
| .array_vmo = ::fidl::HLCPPToNatural(std::move(value.array_vmo)), |
| .array_client_end = ::fidl::HLCPPToNatural(std::move(value.array_client_end)), |
| .array_server_end = ::fidl::HLCPPToNatural(std::move(value.array_server_end)), |
| .array_struct = ::fidl::HLCPPToNatural(std::move(value.array_struct)), |
| .array_table = ::fidl::HLCPPToNatural(std::move(value.array_table)), |
| .array_union = ::fidl::HLCPPToNatural(std::move(value.array_union)), |
| .vector_handle = ::fidl::HLCPPToNatural(std::move(value.vector_handle)), |
| .vector_vmo = ::fidl::HLCPPToNatural(std::move(value.vector_vmo)), |
| .vector_client_end = ::fidl::HLCPPToNatural(std::move(value.vector_client_end)), |
| .vector_server_end = ::fidl::HLCPPToNatural(std::move(value.vector_server_end)), |
| .vector_struct = ::fidl::HLCPPToNatural(std::move(value.vector_struct)), |
| .vector_table = ::fidl::HLCPPToNatural(std::move(value.vector_table)), |
| .vector_union = ::fidl::HLCPPToNatural(std::move(value.vector_union)), |
| }}; |
| } |
| ::test::typesinprotocols::Table NaturalToHLCPPTraits<::test_typesinprotocols::Table>::Convert(::test_typesinprotocols::Table&& value) { |
| ::test::typesinprotocols::Table hlcpp; |
| return hlcpp; |
| } |
| |
| ::test_typesinprotocols::Table HLCPPToNaturalTraits<::test::typesinprotocols::Table>::Convert(::test::typesinprotocols::Table&& value) { |
| ::test_typesinprotocols::Table natural; |
| return natural; |
| } |
| ::test::typesinprotocols::ResourceTable NaturalToHLCPPTraits<::test_typesinprotocols::ResourceTable>::Convert(::test_typesinprotocols::ResourceTable&& value) { |
| ::test::typesinprotocols::ResourceTable hlcpp; |
| return hlcpp; |
| } |
| |
| ::test_typesinprotocols::ResourceTable HLCPPToNaturalTraits<::test::typesinprotocols::ResourceTable>::Convert(::test::typesinprotocols::ResourceTable&& value) { |
| ::test_typesinprotocols::ResourceTable natural; |
| return natural; |
| } |
| |
| ::test::typesinprotocols::Union NaturalToHLCPPTraits<::test_typesinprotocols::Union>::Convert(::test_typesinprotocols::Union&& value) { |
| ::test::typesinprotocols::Union hlcpp; |
| switch (value.Which()) { |
| case ::test_typesinprotocols::Union::Tag::kB: |
| hlcpp.set_b(::fidl::NaturalToHLCPP(std::move(value.b().value()))); |
| break; |
| default: |
| break; |
| } |
| return hlcpp; |
| } |
| |
| ::test_typesinprotocols::Union HLCPPToNaturalTraits<::test::typesinprotocols::Union>::Convert(::test::typesinprotocols::Union&& value) { |
| using _NaturalUnion = ::test_typesinprotocols::Union; |
| switch (value.Which()) { |
| case ::test::typesinprotocols::Union::Tag::kB: |
| return _NaturalUnion::WithB( |
| ::fidl::HLCPPToNatural(std::move(value.b()))); |
| default: |
| return _NaturalUnion(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag{}); |
| } |
| } |
| ::test::typesinprotocols::ResourceUnion NaturalToHLCPPTraits<::test_typesinprotocols::ResourceUnion>::Convert(::test_typesinprotocols::ResourceUnion&& value) { |
| ::test::typesinprotocols::ResourceUnion hlcpp; |
| switch (value.Which()) { |
| case ::test_typesinprotocols::ResourceUnion::Tag::kB: |
| hlcpp.set_b(::fidl::NaturalToHLCPP(std::move(value.b().value()))); |
| break; |
| default: |
| break; |
| } |
| return hlcpp; |
| } |
| |
| ::test_typesinprotocols::ResourceUnion HLCPPToNaturalTraits<::test::typesinprotocols::ResourceUnion>::Convert(::test::typesinprotocols::ResourceUnion&& value) { |
| using _NaturalUnion = ::test_typesinprotocols::ResourceUnion; |
| switch (value.Which()) { |
| case ::test::typesinprotocols::ResourceUnion::Tag::kB: |
| return _NaturalUnion::WithB( |
| ::fidl::HLCPPToNatural(std::move(value.b()))); |
| default: |
| return _NaturalUnion(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag{}); |
| } |
| } |
| ::test::typesinprotocols::Protocol_ErrorBasic_Result NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorBasicResult>::Convert(::test_typesinprotocols::ProtocolErrorBasicResult&& value) { |
| ::test::typesinprotocols::Protocol_ErrorBasic_Result hlcpp; |
| switch (value.Which()) { |
| case ::test_typesinprotocols::ProtocolErrorBasicResult::Tag::kResponse: |
| hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value()))); |
| break; |
| case ::test_typesinprotocols::ProtocolErrorBasicResult::Tag::kErr: |
| hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value()))); |
| break; |
| default: |
| break; |
| } |
| return hlcpp; |
| } |
| |
| ::test_typesinprotocols::ProtocolErrorBasicResult HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorBasic_Result>::Convert(::test::typesinprotocols::Protocol_ErrorBasic_Result&& value) { |
| using _NaturalUnion = ::test_typesinprotocols::ProtocolErrorBasicResult; |
| switch (value.Which()) { |
| case ::test::typesinprotocols::Protocol_ErrorBasic_Result::Tag::kResponse: |
| return _NaturalUnion::WithResponse( |
| ::fidl::HLCPPToNatural(std::move(value.response()))); |
| case ::test::typesinprotocols::Protocol_ErrorBasic_Result::Tag::kErr: |
| return _NaturalUnion::WithErr( |
| ::fidl::HLCPPToNatural(std::move(value.err()))); |
| default: |
| ZX_PANIC("Can't convert invalid strict union %s from HLCPP to Natural", "::test::typesinprotocols::Protocol_ErrorBasic_Result"); |
| } |
| } |
| ::test::typesinprotocols::Protocol_ErrorCompound_Result NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorCompoundResult>::Convert(::test_typesinprotocols::ProtocolErrorCompoundResult&& value) { |
| ::test::typesinprotocols::Protocol_ErrorCompound_Result hlcpp; |
| switch (value.Which()) { |
| case ::test_typesinprotocols::ProtocolErrorCompoundResult::Tag::kResponse: |
| hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value()))); |
| break; |
| case ::test_typesinprotocols::ProtocolErrorCompoundResult::Tag::kErr: |
| hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value()))); |
| break; |
| default: |
| break; |
| } |
| return hlcpp; |
| } |
| |
| ::test_typesinprotocols::ProtocolErrorCompoundResult HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorCompound_Result>::Convert(::test::typesinprotocols::Protocol_ErrorCompound_Result&& value) { |
| using _NaturalUnion = ::test_typesinprotocols::ProtocolErrorCompoundResult; |
| switch (value.Which()) { |
| case ::test::typesinprotocols::Protocol_ErrorCompound_Result::Tag::kResponse: |
| return _NaturalUnion::WithResponse( |
| ::fidl::HLCPPToNatural(std::move(value.response()))); |
| case ::test::typesinprotocols::Protocol_ErrorCompound_Result::Tag::kErr: |
| return _NaturalUnion::WithErr( |
| ::fidl::HLCPPToNatural(std::move(value.err()))); |
| default: |
| ZX_PANIC("Can't convert invalid strict union %s from HLCPP to Natural", "::test::typesinprotocols::Protocol_ErrorCompound_Result"); |
| } |
| } |
| ::test::typesinprotocols::Protocol_ErrorArrayBasic_Result NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorArrayBasicResult>::Convert(::test_typesinprotocols::ProtocolErrorArrayBasicResult&& value) { |
| ::test::typesinprotocols::Protocol_ErrorArrayBasic_Result hlcpp; |
| switch (value.Which()) { |
| case ::test_typesinprotocols::ProtocolErrorArrayBasicResult::Tag::kResponse: |
| hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value()))); |
| break; |
| case ::test_typesinprotocols::ProtocolErrorArrayBasicResult::Tag::kErr: |
| hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value()))); |
| break; |
| default: |
| break; |
| } |
| return hlcpp; |
| } |
| |
| ::test_typesinprotocols::ProtocolErrorArrayBasicResult HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorArrayBasic_Result>::Convert(::test::typesinprotocols::Protocol_ErrorArrayBasic_Result&& value) { |
| using _NaturalUnion = ::test_typesinprotocols::ProtocolErrorArrayBasicResult; |
| switch (value.Which()) { |
| case ::test::typesinprotocols::Protocol_ErrorArrayBasic_Result::Tag::kResponse: |
| return _NaturalUnion::WithResponse( |
| ::fidl::HLCPPToNatural(std::move(value.response()))); |
| case ::test::typesinprotocols::Protocol_ErrorArrayBasic_Result::Tag::kErr: |
| return _NaturalUnion::WithErr( |
| ::fidl::HLCPPToNatural(std::move(value.err()))); |
| default: |
| ZX_PANIC("Can't convert invalid strict union %s from HLCPP to Natural", "::test::typesinprotocols::Protocol_ErrorArrayBasic_Result"); |
| } |
| } |
| ::test::typesinprotocols::Protocol_ErrorArrayCompound_Result NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorArrayCompoundResult>::Convert(::test_typesinprotocols::ProtocolErrorArrayCompoundResult&& value) { |
| ::test::typesinprotocols::Protocol_ErrorArrayCompound_Result hlcpp; |
| switch (value.Which()) { |
| case ::test_typesinprotocols::ProtocolErrorArrayCompoundResult::Tag::kResponse: |
| hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value()))); |
| break; |
| case ::test_typesinprotocols::ProtocolErrorArrayCompoundResult::Tag::kErr: |
| hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value()))); |
| break; |
| default: |
| break; |
| } |
| return hlcpp; |
| } |
| |
| ::test_typesinprotocols::ProtocolErrorArrayCompoundResult HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorArrayCompound_Result>::Convert(::test::typesinprotocols::Protocol_ErrorArrayCompound_Result&& value) { |
| using _NaturalUnion = ::test_typesinprotocols::ProtocolErrorArrayCompoundResult; |
| switch (value.Which()) { |
| case ::test::typesinprotocols::Protocol_ErrorArrayCompound_Result::Tag::kResponse: |
| return _NaturalUnion::WithResponse( |
| ::fidl::HLCPPToNatural(std::move(value.response()))); |
| case ::test::typesinprotocols::Protocol_ErrorArrayCompound_Result::Tag::kErr: |
| return _NaturalUnion::WithErr( |
| ::fidl::HLCPPToNatural(std::move(value.err()))); |
| default: |
| ZX_PANIC("Can't convert invalid strict union %s from HLCPP to Natural", "::test::typesinprotocols::Protocol_ErrorArrayCompound_Result"); |
| } |
| } |
| ::test::typesinprotocols::Protocol_ErrorVectorBasic_Result NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorVectorBasicResult>::Convert(::test_typesinprotocols::ProtocolErrorVectorBasicResult&& value) { |
| ::test::typesinprotocols::Protocol_ErrorVectorBasic_Result hlcpp; |
| switch (value.Which()) { |
| case ::test_typesinprotocols::ProtocolErrorVectorBasicResult::Tag::kResponse: |
| hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value()))); |
| break; |
| case ::test_typesinprotocols::ProtocolErrorVectorBasicResult::Tag::kErr: |
| hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value()))); |
| break; |
| default: |
| break; |
| } |
| return hlcpp; |
| } |
| |
| ::test_typesinprotocols::ProtocolErrorVectorBasicResult HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorVectorBasic_Result>::Convert(::test::typesinprotocols::Protocol_ErrorVectorBasic_Result&& value) { |
| using _NaturalUnion = ::test_typesinprotocols::ProtocolErrorVectorBasicResult; |
| switch (value.Which()) { |
| case ::test::typesinprotocols::Protocol_ErrorVectorBasic_Result::Tag::kResponse: |
| return _NaturalUnion::WithResponse( |
| ::fidl::HLCPPToNatural(std::move(value.response()))); |
| case ::test::typesinprotocols::Protocol_ErrorVectorBasic_Result::Tag::kErr: |
| return _NaturalUnion::WithErr( |
| ::fidl::HLCPPToNatural(std::move(value.err()))); |
| default: |
| ZX_PANIC("Can't convert invalid strict union %s from HLCPP to Natural", "::test::typesinprotocols::Protocol_ErrorVectorBasic_Result"); |
| } |
| } |
| ::test::typesinprotocols::Protocol_ErrorVectorCompound_Result NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorVectorCompoundResult>::Convert(::test_typesinprotocols::ProtocolErrorVectorCompoundResult&& value) { |
| ::test::typesinprotocols::Protocol_ErrorVectorCompound_Result hlcpp; |
| switch (value.Which()) { |
| case ::test_typesinprotocols::ProtocolErrorVectorCompoundResult::Tag::kResponse: |
| hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value()))); |
| break; |
| case ::test_typesinprotocols::ProtocolErrorVectorCompoundResult::Tag::kErr: |
| hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value()))); |
| break; |
| default: |
| break; |
| } |
| return hlcpp; |
| } |
| |
| ::test_typesinprotocols::ProtocolErrorVectorCompoundResult HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorVectorCompound_Result>::Convert(::test::typesinprotocols::Protocol_ErrorVectorCompound_Result&& value) { |
| using _NaturalUnion = ::test_typesinprotocols::ProtocolErrorVectorCompoundResult; |
| switch (value.Which()) { |
| case ::test::typesinprotocols::Protocol_ErrorVectorCompound_Result::Tag::kResponse: |
| return _NaturalUnion::WithResponse( |
| ::fidl::HLCPPToNatural(std::move(value.response()))); |
| case ::test::typesinprotocols::Protocol_ErrorVectorCompound_Result::Tag::kErr: |
| return _NaturalUnion::WithErr( |
| ::fidl::HLCPPToNatural(std::move(value.err()))); |
| default: |
| ZX_PANIC("Can't convert invalid strict union %s from HLCPP to Natural", "::test::typesinprotocols::Protocol_ErrorVectorCompound_Result"); |
| } |
| } |
| ::test::typesinprotocols::Protocol_ErrorVectorOptional_Result NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorVectorOptionalResult>::Convert(::test_typesinprotocols::ProtocolErrorVectorOptionalResult&& value) { |
| ::test::typesinprotocols::Protocol_ErrorVectorOptional_Result hlcpp; |
| switch (value.Which()) { |
| case ::test_typesinprotocols::ProtocolErrorVectorOptionalResult::Tag::kResponse: |
| hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value()))); |
| break; |
| case ::test_typesinprotocols::ProtocolErrorVectorOptionalResult::Tag::kErr: |
| hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value()))); |
| break; |
| default: |
| break; |
| } |
| return hlcpp; |
| } |
| |
| ::test_typesinprotocols::ProtocolErrorVectorOptionalResult HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorVectorOptional_Result>::Convert(::test::typesinprotocols::Protocol_ErrorVectorOptional_Result&& value) { |
| using _NaturalUnion = ::test_typesinprotocols::ProtocolErrorVectorOptionalResult; |
| switch (value.Which()) { |
| case ::test::typesinprotocols::Protocol_ErrorVectorOptional_Result::Tag::kResponse: |
| return _NaturalUnion::WithResponse( |
| ::fidl::HLCPPToNatural(std::move(value.response()))); |
| case ::test::typesinprotocols::Protocol_ErrorVectorOptional_Result::Tag::kErr: |
| return _NaturalUnion::WithErr( |
| ::fidl::HLCPPToNatural(std::move(value.err()))); |
| default: |
| ZX_PANIC("Can't convert invalid strict union %s from HLCPP to Natural", "::test::typesinprotocols::Protocol_ErrorVectorOptional_Result"); |
| } |
| } |
| ::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorArrayVectorNestedResult>::Convert(::test_typesinprotocols::ProtocolErrorArrayVectorNestedResult&& value) { |
| ::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result hlcpp; |
| switch (value.Which()) { |
| case ::test_typesinprotocols::ProtocolErrorArrayVectorNestedResult::Tag::kResponse: |
| hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value()))); |
| break; |
| case ::test_typesinprotocols::ProtocolErrorArrayVectorNestedResult::Tag::kErr: |
| hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value()))); |
| break; |
| default: |
| break; |
| } |
| return hlcpp; |
| } |
| |
| ::test_typesinprotocols::ProtocolErrorArrayVectorNestedResult HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result>::Convert(::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result&& value) { |
| using _NaturalUnion = ::test_typesinprotocols::ProtocolErrorArrayVectorNestedResult; |
| switch (value.Which()) { |
| case ::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result::Tag::kResponse: |
| return _NaturalUnion::WithResponse( |
| ::fidl::HLCPPToNatural(std::move(value.response()))); |
| case ::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result::Tag::kErr: |
| return _NaturalUnion::WithErr( |
| ::fidl::HLCPPToNatural(std::move(value.err()))); |
| default: |
| ZX_PANIC("Can't convert invalid strict union %s from HLCPP to Natural", "::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result"); |
| } |
| } |
| ::test::typesinprotocols::Protocol_ErrorResource_Result NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorResourceResult>::Convert(::test_typesinprotocols::ProtocolErrorResourceResult&& value) { |
| ::test::typesinprotocols::Protocol_ErrorResource_Result hlcpp; |
| switch (value.Which()) { |
| case ::test_typesinprotocols::ProtocolErrorResourceResult::Tag::kResponse: |
| hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value()))); |
| break; |
| case ::test_typesinprotocols::ProtocolErrorResourceResult::Tag::kErr: |
| hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value()))); |
| break; |
| default: |
| break; |
| } |
| return hlcpp; |
| } |
| |
| ::test_typesinprotocols::ProtocolErrorResourceResult HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorResource_Result>::Convert(::test::typesinprotocols::Protocol_ErrorResource_Result&& value) { |
| using _NaturalUnion = ::test_typesinprotocols::ProtocolErrorResourceResult; |
| switch (value.Which()) { |
| case ::test::typesinprotocols::Protocol_ErrorResource_Result::Tag::kResponse: |
| return _NaturalUnion::WithResponse( |
| ::fidl::HLCPPToNatural(std::move(value.response()))); |
| case ::test::typesinprotocols::Protocol_ErrorResource_Result::Tag::kErr: |
| return _NaturalUnion::WithErr( |
| ::fidl::HLCPPToNatural(std::move(value.err()))); |
| default: |
| ZX_PANIC("Can't convert invalid strict union %s from HLCPP to Natural", "::test::typesinprotocols::Protocol_ErrorResource_Result"); |
| } |
| } |
| |
| #pragma clang diagnostic pop |
| |
| } // namespace internal |
| } // namespace fidl |