// Generated by the protocol buffer compiler. DO NOT EDIT! // source: keyapis/telemetry_control/v1/keyapis_telemetry_control_stream_v1.proto #ifndef GOOGLE_PROTOBUF_INCLUDED_keyapis_2ftelemetry_5fcontrol_2fv1_2fkeyapis_5ftelemetry_5fcontrol_5fstream_5fv1_2eproto_2epb_2eh #define GOOGLE_PROTOBUF_INCLUDED_keyapis_2ftelemetry_5fcontrol_2fv1_2fkeyapis_5ftelemetry_5fcontrol_5fstream_5fv1_2eproto_2epb_2eh #include #include #include #include "google/protobuf/port_def.inc" #if PROTOBUF_VERSION < 4023000 #error "This file was generated by a newer version of protoc which is" #error "incompatible with your Protocol Buffer headers. Please update" #error "your headers." #endif // PROTOBUF_VERSION #if 4023001 < PROTOBUF_MIN_PROTOC_VERSION #error "This file was generated by an older version of protoc which is" #error "incompatible with your Protocol Buffer headers. Please" #error "regenerate this file with a newer version of protoc." #endif // PROTOBUF_MIN_PROTOC_VERSION #include "google/protobuf/port_undef.inc" #include "google/protobuf/io/coded_stream.h" #include "google/protobuf/arena.h" #include "google/protobuf/arenastring.h" #include "google/protobuf/generated_message_util.h" #include "google/protobuf/metadata_lite.h" #include "google/protobuf/message_lite.h" #include "google/protobuf/repeated_field.h" // IWYU pragma: export #include "google/protobuf/extension_set.h" // IWYU pragma: export #include "google/api/field_behavior.pb.h" #include "keyapis/telemetry_control/v1/keyapis_telemetry_control_building_v1.pb.h" #include "keyapis/telemetry_control/v1/keyapis_telemetry_control_device_v1.pb.h" // @@protoc_insertion_point(includes) // Must be included last. #include "google/protobuf/port_def.inc" #define PROTOBUF_INTERNAL_EXPORT_keyapis_2ftelemetry_5fcontrol_2fv1_2fkeyapis_5ftelemetry_5fcontrol_5fstream_5fv1_2eproto PROTOBUF_NAMESPACE_OPEN namespace internal { class AnyMetadata; } // namespace internal PROTOBUF_NAMESPACE_CLOSE // Internal implementation detail -- do not use these members. struct TableStruct_keyapis_2ftelemetry_5fcontrol_2fv1_2fkeyapis_5ftelemetry_5fcontrol_5fstream_5fv1_2eproto { static const ::uint32_t offsets[]; }; namespace keyapis { namespace telemetry_control { namespace v1 { class PostResourceFullDuplexRequest; struct PostResourceFullDuplexRequestDefaultTypeInternal; extern PostResourceFullDuplexRequestDefaultTypeInternal _PostResourceFullDuplexRequest_default_instance_; class PostResourceFullDuplexRequest_ResourceAsyncStatus; struct PostResourceFullDuplexRequest_ResourceAsyncStatusDefaultTypeInternal; extern PostResourceFullDuplexRequest_ResourceAsyncStatusDefaultTypeInternal _PostResourceFullDuplexRequest_ResourceAsyncStatus_default_instance_; class PostResourceFullDuplexRequest_ResourceAsyncStatus_Error; struct PostResourceFullDuplexRequest_ResourceAsyncStatus_ErrorDefaultTypeInternal; extern PostResourceFullDuplexRequest_ResourceAsyncStatus_ErrorDefaultTypeInternal _PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_default_instance_; class PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError; struct PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownErrorDefaultTypeInternal; extern PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownErrorDefaultTypeInternal _PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError_default_instance_; class PostResourceFullDuplexRequest_ResourceAsyncStatus_Success; struct PostResourceFullDuplexRequest_ResourceAsyncStatus_SuccessDefaultTypeInternal; extern PostResourceFullDuplexRequest_ResourceAsyncStatus_SuccessDefaultTypeInternal _PostResourceFullDuplexRequest_ResourceAsyncStatus_Success_default_instance_; class PostResourceFullDuplexResponse; struct PostResourceFullDuplexResponseDefaultTypeInternal; extern PostResourceFullDuplexResponseDefaultTypeInternal _PostResourceFullDuplexResponse_default_instance_; class PostResourceFullDuplexResponse_RemoveResourceEvent; struct PostResourceFullDuplexResponse_RemoveResourceEventDefaultTypeInternal; extern PostResourceFullDuplexResponse_RemoveResourceEventDefaultTypeInternal _PostResourceFullDuplexResponse_RemoveResourceEvent_default_instance_; class PostResourceFullDuplexResponse_UpsertResourceEvent; struct PostResourceFullDuplexResponse_UpsertResourceEventDefaultTypeInternal; extern PostResourceFullDuplexResponse_UpsertResourceEventDefaultTypeInternal _PostResourceFullDuplexResponse_UpsertResourceEvent_default_instance_; class Resource; struct ResourceDefaultTypeInternal; extern ResourceDefaultTypeInternal _Resource_default_instance_; class ResourceId; struct ResourceIdDefaultTypeInternal; extern ResourceIdDefaultTypeInternal _ResourceId_default_instance_; } // namespace v1 } // namespace telemetry_control } // namespace keyapis PROTOBUF_NAMESPACE_OPEN template <> ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest* Arena::CreateMaybeMessage<::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest>(Arena*); template <> ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus* Arena::CreateMaybeMessage<::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus>(Arena*); template <> ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error* Arena::CreateMaybeMessage<::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error>(Arena*); template <> ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError* Arena::CreateMaybeMessage<::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError>(Arena*); template <> ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Success* Arena::CreateMaybeMessage<::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Success>(Arena*); template <> ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse* Arena::CreateMaybeMessage<::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse>(Arena*); template <> ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_RemoveResourceEvent* Arena::CreateMaybeMessage<::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_RemoveResourceEvent>(Arena*); template <> ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_UpsertResourceEvent* Arena::CreateMaybeMessage<::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_UpsertResourceEvent>(Arena*); template <> ::keyapis::telemetry_control::v1::Resource* Arena::CreateMaybeMessage<::keyapis::telemetry_control::v1::Resource>(Arena*); template <> ::keyapis::telemetry_control::v1::ResourceId* Arena::CreateMaybeMessage<::keyapis::telemetry_control::v1::ResourceId>(Arena*); PROTOBUF_NAMESPACE_CLOSE namespace keyapis { namespace telemetry_control { namespace v1 { // =================================================================== // ------------------------------------------------------------------- class PostResourceFullDuplexResponse_RemoveResourceEvent final : public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.RemoveResourceEvent) */ { public: inline PostResourceFullDuplexResponse_RemoveResourceEvent() : PostResourceFullDuplexResponse_RemoveResourceEvent(nullptr) {} ~PostResourceFullDuplexResponse_RemoveResourceEvent() override; template explicit PROTOBUF_CONSTEXPR PostResourceFullDuplexResponse_RemoveResourceEvent(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); PostResourceFullDuplexResponse_RemoveResourceEvent(const PostResourceFullDuplexResponse_RemoveResourceEvent& from); PostResourceFullDuplexResponse_RemoveResourceEvent(PostResourceFullDuplexResponse_RemoveResourceEvent&& from) noexcept : PostResourceFullDuplexResponse_RemoveResourceEvent() { *this = ::std::move(from); } inline PostResourceFullDuplexResponse_RemoveResourceEvent& operator=(const PostResourceFullDuplexResponse_RemoveResourceEvent& from) { CopyFrom(from); return *this; } inline PostResourceFullDuplexResponse_RemoveResourceEvent& operator=(PostResourceFullDuplexResponse_RemoveResourceEvent&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const std::string& unknown_fields() const { return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); } inline std::string* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields(); } static const PostResourceFullDuplexResponse_RemoveResourceEvent& default_instance() { return *internal_default_instance(); } static inline const PostResourceFullDuplexResponse_RemoveResourceEvent* internal_default_instance() { return reinterpret_cast( &_PostResourceFullDuplexResponse_RemoveResourceEvent_default_instance_); } static constexpr int kIndexInFileMessages = 0; friend void swap(PostResourceFullDuplexResponse_RemoveResourceEvent& a, PostResourceFullDuplexResponse_RemoveResourceEvent& b) { a.Swap(&b); } inline void Swap(PostResourceFullDuplexResponse_RemoveResourceEvent* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PostResourceFullDuplexResponse_RemoveResourceEvent* other) { if (other == this) return; ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PostResourceFullDuplexResponse_RemoveResourceEvent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; void CopyFrom(const PostResourceFullDuplexResponse_RemoveResourceEvent& from); void MergeFrom(const PostResourceFullDuplexResponse_RemoveResourceEvent& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); void SharedDtor(); void SetCachedSize(int size) const; void InternalSwap(PostResourceFullDuplexResponse_RemoveResourceEvent* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.RemoveResourceEvent"; } protected: explicit PostResourceFullDuplexResponse_RemoveResourceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: std::string GetTypeName() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kResourceIdFieldNumber = 1, }; // .keyapis.telemetry_control.v1.ResourceId resource_id = 1 [(.google.api.field_behavior) = REQUIRED]; bool has_resource_id() const; void clear_resource_id() ; const ::keyapis::telemetry_control::v1::ResourceId& resource_id() const; PROTOBUF_NODISCARD ::keyapis::telemetry_control::v1::ResourceId* release_resource_id(); ::keyapis::telemetry_control::v1::ResourceId* mutable_resource_id(); void set_allocated_resource_id(::keyapis::telemetry_control::v1::ResourceId* resource_id); private: const ::keyapis::telemetry_control::v1::ResourceId& _internal_resource_id() const; ::keyapis::telemetry_control::v1::ResourceId* _internal_mutable_resource_id(); public: void unsafe_arena_set_allocated_resource_id( ::keyapis::telemetry_control::v1::ResourceId* resource_id); ::keyapis::telemetry_control::v1::ResourceId* unsafe_arena_release_resource_id(); // @@protoc_insertion_point(class_scope:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.RemoveResourceEvent) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::keyapis::telemetry_control::v1::ResourceId* resource_id_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_keyapis_2ftelemetry_5fcontrol_2fv1_2fkeyapis_5ftelemetry_5fcontrol_5fstream_5fv1_2eproto; };// ------------------------------------------------------------------- class PostResourceFullDuplexResponse_UpsertResourceEvent final : public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.UpsertResourceEvent) */ { public: inline PostResourceFullDuplexResponse_UpsertResourceEvent() : PostResourceFullDuplexResponse_UpsertResourceEvent(nullptr) {} ~PostResourceFullDuplexResponse_UpsertResourceEvent() override; template explicit PROTOBUF_CONSTEXPR PostResourceFullDuplexResponse_UpsertResourceEvent(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); PostResourceFullDuplexResponse_UpsertResourceEvent(const PostResourceFullDuplexResponse_UpsertResourceEvent& from); PostResourceFullDuplexResponse_UpsertResourceEvent(PostResourceFullDuplexResponse_UpsertResourceEvent&& from) noexcept : PostResourceFullDuplexResponse_UpsertResourceEvent() { *this = ::std::move(from); } inline PostResourceFullDuplexResponse_UpsertResourceEvent& operator=(const PostResourceFullDuplexResponse_UpsertResourceEvent& from) { CopyFrom(from); return *this; } inline PostResourceFullDuplexResponse_UpsertResourceEvent& operator=(PostResourceFullDuplexResponse_UpsertResourceEvent&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const std::string& unknown_fields() const { return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); } inline std::string* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields(); } static const PostResourceFullDuplexResponse_UpsertResourceEvent& default_instance() { return *internal_default_instance(); } static inline const PostResourceFullDuplexResponse_UpsertResourceEvent* internal_default_instance() { return reinterpret_cast( &_PostResourceFullDuplexResponse_UpsertResourceEvent_default_instance_); } static constexpr int kIndexInFileMessages = 1; friend void swap(PostResourceFullDuplexResponse_UpsertResourceEvent& a, PostResourceFullDuplexResponse_UpsertResourceEvent& b) { a.Swap(&b); } inline void Swap(PostResourceFullDuplexResponse_UpsertResourceEvent* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PostResourceFullDuplexResponse_UpsertResourceEvent* other) { if (other == this) return; ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PostResourceFullDuplexResponse_UpsertResourceEvent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; void CopyFrom(const PostResourceFullDuplexResponse_UpsertResourceEvent& from); void MergeFrom(const PostResourceFullDuplexResponse_UpsertResourceEvent& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); void SharedDtor(); void SetCachedSize(int size) const; void InternalSwap(PostResourceFullDuplexResponse_UpsertResourceEvent* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.UpsertResourceEvent"; } protected: explicit PostResourceFullDuplexResponse_UpsertResourceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: std::string GetTypeName() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kResourceFieldNumber = 1, }; // .keyapis.telemetry_control.v1.Resource resource = 1 [(.google.api.field_behavior) = REQUIRED]; bool has_resource() const; void clear_resource() ; const ::keyapis::telemetry_control::v1::Resource& resource() const; PROTOBUF_NODISCARD ::keyapis::telemetry_control::v1::Resource* release_resource(); ::keyapis::telemetry_control::v1::Resource* mutable_resource(); void set_allocated_resource(::keyapis::telemetry_control::v1::Resource* resource); private: const ::keyapis::telemetry_control::v1::Resource& _internal_resource() const; ::keyapis::telemetry_control::v1::Resource* _internal_mutable_resource(); public: void unsafe_arena_set_allocated_resource( ::keyapis::telemetry_control::v1::Resource* resource); ::keyapis::telemetry_control::v1::Resource* unsafe_arena_release_resource(); // @@protoc_insertion_point(class_scope:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.UpsertResourceEvent) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::keyapis::telemetry_control::v1::Resource* resource_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_keyapis_2ftelemetry_5fcontrol_2fv1_2fkeyapis_5ftelemetry_5fcontrol_5fstream_5fv1_2eproto; };// ------------------------------------------------------------------- class PostResourceFullDuplexResponse final : public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse) */ { public: inline PostResourceFullDuplexResponse() : PostResourceFullDuplexResponse(nullptr) {} ~PostResourceFullDuplexResponse() override; template explicit PROTOBUF_CONSTEXPR PostResourceFullDuplexResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); PostResourceFullDuplexResponse(const PostResourceFullDuplexResponse& from); PostResourceFullDuplexResponse(PostResourceFullDuplexResponse&& from) noexcept : PostResourceFullDuplexResponse() { *this = ::std::move(from); } inline PostResourceFullDuplexResponse& operator=(const PostResourceFullDuplexResponse& from) { CopyFrom(from); return *this; } inline PostResourceFullDuplexResponse& operator=(PostResourceFullDuplexResponse&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const std::string& unknown_fields() const { return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); } inline std::string* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields(); } static const PostResourceFullDuplexResponse& default_instance() { return *internal_default_instance(); } enum EventCase { kUpsertResourceEvent = 2, kRemoveResourceEvent = 3, EVENT_NOT_SET = 0, }; static inline const PostResourceFullDuplexResponse* internal_default_instance() { return reinterpret_cast( &_PostResourceFullDuplexResponse_default_instance_); } static constexpr int kIndexInFileMessages = 2; friend void swap(PostResourceFullDuplexResponse& a, PostResourceFullDuplexResponse& b) { a.Swap(&b); } inline void Swap(PostResourceFullDuplexResponse* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PostResourceFullDuplexResponse* other) { if (other == this) return; ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PostResourceFullDuplexResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; void CopyFrom(const PostResourceFullDuplexResponse& from); void MergeFrom(const PostResourceFullDuplexResponse& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); void SharedDtor(); void SetCachedSize(int size) const; void InternalSwap(PostResourceFullDuplexResponse* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "keyapis.telemetry_control.v1.PostResourceFullDuplexResponse"; } protected: explicit PostResourceFullDuplexResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: std::string GetTypeName() const final; // nested types ---------------------------------------------------- typedef PostResourceFullDuplexResponse_RemoveResourceEvent RemoveResourceEvent; typedef PostResourceFullDuplexResponse_UpsertResourceEvent UpsertResourceEvent; // accessors ------------------------------------------------------- enum : int { kRequestIdFieldNumber = 1, kUpsertResourceEventFieldNumber = 2, kRemoveResourceEventFieldNumber = 3, }; // string request_id = 1 [(.google.api.field_behavior) = REQUIRED]; void clear_request_id() ; const std::string& request_id() const; template void set_request_id(Arg_&& arg, Args_... args); std::string* mutable_request_id(); PROTOBUF_NODISCARD std::string* release_request_id(); void set_allocated_request_id(std::string* ptr); private: const std::string& _internal_request_id() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_request_id( const std::string& value); std::string* _internal_mutable_request_id(); public: // .keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.UpsertResourceEvent upsert_resource_event = 2; bool has_upsert_resource_event() const; private: bool _internal_has_upsert_resource_event() const; public: void clear_upsert_resource_event() ; const ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_UpsertResourceEvent& upsert_resource_event() const; PROTOBUF_NODISCARD ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_UpsertResourceEvent* release_upsert_resource_event(); ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_UpsertResourceEvent* mutable_upsert_resource_event(); void set_allocated_upsert_resource_event(::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_UpsertResourceEvent* upsert_resource_event); private: const ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_UpsertResourceEvent& _internal_upsert_resource_event() const; ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_UpsertResourceEvent* _internal_mutable_upsert_resource_event(); public: void unsafe_arena_set_allocated_upsert_resource_event( ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_UpsertResourceEvent* upsert_resource_event); ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_UpsertResourceEvent* unsafe_arena_release_upsert_resource_event(); // .keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.RemoveResourceEvent remove_resource_event = 3; bool has_remove_resource_event() const; private: bool _internal_has_remove_resource_event() const; public: void clear_remove_resource_event() ; const ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_RemoveResourceEvent& remove_resource_event() const; PROTOBUF_NODISCARD ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_RemoveResourceEvent* release_remove_resource_event(); ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_RemoveResourceEvent* mutable_remove_resource_event(); void set_allocated_remove_resource_event(::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_RemoveResourceEvent* remove_resource_event); private: const ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_RemoveResourceEvent& _internal_remove_resource_event() const; ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_RemoveResourceEvent* _internal_mutable_remove_resource_event(); public: void unsafe_arena_set_allocated_remove_resource_event( ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_RemoveResourceEvent* remove_resource_event); ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_RemoveResourceEvent* unsafe_arena_release_remove_resource_event(); void clear_event(); EventCase event_case() const; // @@protoc_insertion_point(class_scope:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse) private: class _Internal; void set_has_upsert_resource_event(); void set_has_remove_resource_event(); inline bool has_event() const; inline void clear_has_event(); template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_id_; union EventUnion { constexpr EventUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_UpsertResourceEvent* upsert_resource_event_; ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_RemoveResourceEvent* remove_resource_event_; } event_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::uint32_t _oneof_case_[1]; }; union { Impl_ _impl_; }; friend struct ::TableStruct_keyapis_2ftelemetry_5fcontrol_2fv1_2fkeyapis_5ftelemetry_5fcontrol_5fstream_5fv1_2eproto; };// ------------------------------------------------------------------- class ResourceId final : public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.telemetry_control.v1.ResourceId) */ { public: inline ResourceId() : ResourceId(nullptr) {} ~ResourceId() override; template explicit PROTOBUF_CONSTEXPR ResourceId(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ResourceId(const ResourceId& from); ResourceId(ResourceId&& from) noexcept : ResourceId() { *this = ::std::move(from); } inline ResourceId& operator=(const ResourceId& from) { CopyFrom(from); return *this; } inline ResourceId& operator=(ResourceId&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const std::string& unknown_fields() const { return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); } inline std::string* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields(); } static const ResourceId& default_instance() { return *internal_default_instance(); } enum TypeCase { kBuildingId = 1, kDeviceId = 2, kMetricPointId = 3, kIndicatorId = 4, kIndicatorMetricPoint = 5, TYPE_NOT_SET = 0, }; static inline const ResourceId* internal_default_instance() { return reinterpret_cast( &_ResourceId_default_instance_); } static constexpr int kIndexInFileMessages = 3; friend void swap(ResourceId& a, ResourceId& b) { a.Swap(&b); } inline void Swap(ResourceId* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ResourceId* other) { if (other == this) return; ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ResourceId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; void CopyFrom(const ResourceId& from); void MergeFrom(const ResourceId& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); void SharedDtor(); void SetCachedSize(int size) const; void InternalSwap(ResourceId* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "keyapis.telemetry_control.v1.ResourceId"; } protected: explicit ResourceId(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: std::string GetTypeName() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBuildingIdFieldNumber = 1, kDeviceIdFieldNumber = 2, kMetricPointIdFieldNumber = 3, kIndicatorIdFieldNumber = 4, kIndicatorMetricPointFieldNumber = 5, }; // int32 building_id = 1; bool has_building_id() const; void clear_building_id() ; ::int32_t building_id() const; void set_building_id(::int32_t value); private: ::int32_t _internal_building_id() const; void _internal_set_building_id(::int32_t value); public: // int32 device_id = 2; bool has_device_id() const; void clear_device_id() ; ::int32_t device_id() const; void set_device_id(::int32_t value); private: ::int32_t _internal_device_id() const; void _internal_set_device_id(::int32_t value); public: // string metric_point_id = 3; bool has_metric_point_id() const; void clear_metric_point_id() ; const std::string& metric_point_id() const; template void set_metric_point_id(Arg_&& arg, Args_... args); std::string* mutable_metric_point_id(); PROTOBUF_NODISCARD std::string* release_metric_point_id(); void set_allocated_metric_point_id(std::string* ptr); private: const std::string& _internal_metric_point_id() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_metric_point_id( const std::string& value); std::string* _internal_mutable_metric_point_id(); public: // int32 indicator_id = 4; bool has_indicator_id() const; void clear_indicator_id() ; ::int32_t indicator_id() const; void set_indicator_id(::int32_t value); private: ::int32_t _internal_indicator_id() const; void _internal_set_indicator_id(::int32_t value); public: // .keyapis.telemetry_control.v1.DeviceIndicatorMetricPoint indicator_metric_point = 5; bool has_indicator_metric_point() const; private: bool _internal_has_indicator_metric_point() const; public: void clear_indicator_metric_point() ; const ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint& indicator_metric_point() const; PROTOBUF_NODISCARD ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* release_indicator_metric_point(); ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* mutable_indicator_metric_point(); void set_allocated_indicator_metric_point(::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* indicator_metric_point); private: const ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint& _internal_indicator_metric_point() const; ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* _internal_mutable_indicator_metric_point(); public: void unsafe_arena_set_allocated_indicator_metric_point( ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* indicator_metric_point); ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* unsafe_arena_release_indicator_metric_point(); void clear_type(); TypeCase type_case() const; // @@protoc_insertion_point(class_scope:keyapis.telemetry_control.v1.ResourceId) private: class _Internal; void set_has_building_id(); void set_has_device_id(); void set_has_metric_point_id(); void set_has_indicator_id(); void set_has_indicator_metric_point(); inline bool has_type() const; inline void clear_has_type(); template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { union TypeUnion { constexpr TypeUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; ::int32_t building_id_; ::int32_t device_id_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr metric_point_id_; ::int32_t indicator_id_; ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* indicator_metric_point_; } type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::uint32_t _oneof_case_[1]; }; union { Impl_ _impl_; }; friend struct ::TableStruct_keyapis_2ftelemetry_5fcontrol_2fv1_2fkeyapis_5ftelemetry_5fcontrol_5fstream_5fv1_2eproto; };// ------------------------------------------------------------------- class Resource final : public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.telemetry_control.v1.Resource) */ { public: inline Resource() : Resource(nullptr) {} ~Resource() override; template explicit PROTOBUF_CONSTEXPR Resource(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); Resource(const Resource& from); Resource(Resource&& from) noexcept : Resource() { *this = ::std::move(from); } inline Resource& operator=(const Resource& from) { CopyFrom(from); return *this; } inline Resource& operator=(Resource&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const std::string& unknown_fields() const { return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); } inline std::string* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields(); } static const Resource& default_instance() { return *internal_default_instance(); } enum TypeCase { kBuilding = 1, kDevice = 2, kMetricPoint = 3, kIndicator = 4, kIndicatorMetricPoint = 5, TYPE_NOT_SET = 0, }; static inline const Resource* internal_default_instance() { return reinterpret_cast( &_Resource_default_instance_); } static constexpr int kIndexInFileMessages = 4; friend void swap(Resource& a, Resource& b) { a.Swap(&b); } inline void Swap(Resource* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(Resource* other) { if (other == this) return; ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- Resource* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; void CopyFrom(const Resource& from); void MergeFrom(const Resource& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); void SharedDtor(); void SetCachedSize(int size) const; void InternalSwap(Resource* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "keyapis.telemetry_control.v1.Resource"; } protected: explicit Resource(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: std::string GetTypeName() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBuildingFieldNumber = 1, kDeviceFieldNumber = 2, kMetricPointFieldNumber = 3, kIndicatorFieldNumber = 4, kIndicatorMetricPointFieldNumber = 5, }; // .keyapis.telemetry_control.v1.Building building = 1; bool has_building() const; private: bool _internal_has_building() const; public: void clear_building() ; const ::keyapis::telemetry_control::v1::Building& building() const; PROTOBUF_NODISCARD ::keyapis::telemetry_control::v1::Building* release_building(); ::keyapis::telemetry_control::v1::Building* mutable_building(); void set_allocated_building(::keyapis::telemetry_control::v1::Building* building); private: const ::keyapis::telemetry_control::v1::Building& _internal_building() const; ::keyapis::telemetry_control::v1::Building* _internal_mutable_building(); public: void unsafe_arena_set_allocated_building( ::keyapis::telemetry_control::v1::Building* building); ::keyapis::telemetry_control::v1::Building* unsafe_arena_release_building(); // .keyapis.telemetry_control.v1.Device device = 2; bool has_device() const; private: bool _internal_has_device() const; public: void clear_device() ; const ::keyapis::telemetry_control::v1::Device& device() const; PROTOBUF_NODISCARD ::keyapis::telemetry_control::v1::Device* release_device(); ::keyapis::telemetry_control::v1::Device* mutable_device(); void set_allocated_device(::keyapis::telemetry_control::v1::Device* device); private: const ::keyapis::telemetry_control::v1::Device& _internal_device() const; ::keyapis::telemetry_control::v1::Device* _internal_mutable_device(); public: void unsafe_arena_set_allocated_device( ::keyapis::telemetry_control::v1::Device* device); ::keyapis::telemetry_control::v1::Device* unsafe_arena_release_device(); // .keyapis.telemetry_control.v1.Device.MetricPoint metric_point = 3; bool has_metric_point() const; private: bool _internal_has_metric_point() const; public: void clear_metric_point() ; const ::keyapis::telemetry_control::v1::Device_MetricPoint& metric_point() const; PROTOBUF_NODISCARD ::keyapis::telemetry_control::v1::Device_MetricPoint* release_metric_point(); ::keyapis::telemetry_control::v1::Device_MetricPoint* mutable_metric_point(); void set_allocated_metric_point(::keyapis::telemetry_control::v1::Device_MetricPoint* metric_point); private: const ::keyapis::telemetry_control::v1::Device_MetricPoint& _internal_metric_point() const; ::keyapis::telemetry_control::v1::Device_MetricPoint* _internal_mutable_metric_point(); public: void unsafe_arena_set_allocated_metric_point( ::keyapis::telemetry_control::v1::Device_MetricPoint* metric_point); ::keyapis::telemetry_control::v1::Device_MetricPoint* unsafe_arena_release_metric_point(); // .keyapis.telemetry_control.v1.Indicator indicator = 4; bool has_indicator() const; private: bool _internal_has_indicator() const; public: void clear_indicator() ; const ::keyapis::telemetry_control::v1::Indicator& indicator() const; PROTOBUF_NODISCARD ::keyapis::telemetry_control::v1::Indicator* release_indicator(); ::keyapis::telemetry_control::v1::Indicator* mutable_indicator(); void set_allocated_indicator(::keyapis::telemetry_control::v1::Indicator* indicator); private: const ::keyapis::telemetry_control::v1::Indicator& _internal_indicator() const; ::keyapis::telemetry_control::v1::Indicator* _internal_mutable_indicator(); public: void unsafe_arena_set_allocated_indicator( ::keyapis::telemetry_control::v1::Indicator* indicator); ::keyapis::telemetry_control::v1::Indicator* unsafe_arena_release_indicator(); // .keyapis.telemetry_control.v1.DeviceIndicatorMetricPoint indicator_metric_point = 5; bool has_indicator_metric_point() const; private: bool _internal_has_indicator_metric_point() const; public: void clear_indicator_metric_point() ; const ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint& indicator_metric_point() const; PROTOBUF_NODISCARD ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* release_indicator_metric_point(); ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* mutable_indicator_metric_point(); void set_allocated_indicator_metric_point(::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* indicator_metric_point); private: const ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint& _internal_indicator_metric_point() const; ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* _internal_mutable_indicator_metric_point(); public: void unsafe_arena_set_allocated_indicator_metric_point( ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* indicator_metric_point); ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* unsafe_arena_release_indicator_metric_point(); void clear_type(); TypeCase type_case() const; // @@protoc_insertion_point(class_scope:keyapis.telemetry_control.v1.Resource) private: class _Internal; void set_has_building(); void set_has_device(); void set_has_metric_point(); void set_has_indicator(); void set_has_indicator_metric_point(); inline bool has_type() const; inline void clear_has_type(); template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { union TypeUnion { constexpr TypeUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; ::keyapis::telemetry_control::v1::Building* building_; ::keyapis::telemetry_control::v1::Device* device_; ::keyapis::telemetry_control::v1::Device_MetricPoint* metric_point_; ::keyapis::telemetry_control::v1::Indicator* indicator_; ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* indicator_metric_point_; } type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::uint32_t _oneof_case_[1]; }; union { Impl_ _impl_; }; friend struct ::TableStruct_keyapis_2ftelemetry_5fcontrol_2fv1_2fkeyapis_5ftelemetry_5fcontrol_5fstream_5fv1_2eproto; };// ------------------------------------------------------------------- class PostResourceFullDuplexRequest_ResourceAsyncStatus_Success final : public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.Success) */ { public: inline PostResourceFullDuplexRequest_ResourceAsyncStatus_Success() : PostResourceFullDuplexRequest_ResourceAsyncStatus_Success(nullptr) {} ~PostResourceFullDuplexRequest_ResourceAsyncStatus_Success() override; template explicit PROTOBUF_CONSTEXPR PostResourceFullDuplexRequest_ResourceAsyncStatus_Success(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); PostResourceFullDuplexRequest_ResourceAsyncStatus_Success(const PostResourceFullDuplexRequest_ResourceAsyncStatus_Success& from); PostResourceFullDuplexRequest_ResourceAsyncStatus_Success(PostResourceFullDuplexRequest_ResourceAsyncStatus_Success&& from) noexcept : PostResourceFullDuplexRequest_ResourceAsyncStatus_Success() { *this = ::std::move(from); } inline PostResourceFullDuplexRequest_ResourceAsyncStatus_Success& operator=(const PostResourceFullDuplexRequest_ResourceAsyncStatus_Success& from) { CopyFrom(from); return *this; } inline PostResourceFullDuplexRequest_ResourceAsyncStatus_Success& operator=(PostResourceFullDuplexRequest_ResourceAsyncStatus_Success&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const std::string& unknown_fields() const { return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); } inline std::string* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields(); } static const PostResourceFullDuplexRequest_ResourceAsyncStatus_Success& default_instance() { return *internal_default_instance(); } static inline const PostResourceFullDuplexRequest_ResourceAsyncStatus_Success* internal_default_instance() { return reinterpret_cast( &_PostResourceFullDuplexRequest_ResourceAsyncStatus_Success_default_instance_); } static constexpr int kIndexInFileMessages = 5; friend void swap(PostResourceFullDuplexRequest_ResourceAsyncStatus_Success& a, PostResourceFullDuplexRequest_ResourceAsyncStatus_Success& b) { a.Swap(&b); } inline void Swap(PostResourceFullDuplexRequest_ResourceAsyncStatus_Success* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PostResourceFullDuplexRequest_ResourceAsyncStatus_Success* other) { if (other == this) return; ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PostResourceFullDuplexRequest_ResourceAsyncStatus_Success* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; void CopyFrom(const PostResourceFullDuplexRequest_ResourceAsyncStatus_Success& from); void MergeFrom(const PostResourceFullDuplexRequest_ResourceAsyncStatus_Success& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); void SharedDtor(); void SetCachedSize(int size) const; void InternalSwap(PostResourceFullDuplexRequest_ResourceAsyncStatus_Success* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.Success"; } protected: explicit PostResourceFullDuplexRequest_ResourceAsyncStatus_Success(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: std::string GetTypeName() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- // @@protoc_insertion_point(class_scope:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.Success) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_keyapis_2ftelemetry_5fcontrol_2fv1_2fkeyapis_5ftelemetry_5fcontrol_5fstream_5fv1_2eproto; };// ------------------------------------------------------------------- class PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError final : public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.Error.UnknownError) */ { public: inline PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError() : PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError(nullptr) {} ~PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError() override; template explicit PROTOBUF_CONSTEXPR PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError(const PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError& from); PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError(PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError&& from) noexcept : PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError() { *this = ::std::move(from); } inline PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError& operator=(const PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError& from) { CopyFrom(from); return *this; } inline PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError& operator=(PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const std::string& unknown_fields() const { return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); } inline std::string* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields(); } static const PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError& default_instance() { return *internal_default_instance(); } static inline const PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError* internal_default_instance() { return reinterpret_cast( &_PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError_default_instance_); } static constexpr int kIndexInFileMessages = 6; friend void swap(PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError& a, PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError& b) { a.Swap(&b); } inline void Swap(PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError* other) { if (other == this) return; ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; void CopyFrom(const PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError& from); void MergeFrom(const PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); void SharedDtor(); void SetCachedSize(int size) const; void InternalSwap(PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.Error.UnknownError"; } protected: explicit PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: std::string GetTypeName() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kMessageFieldNumber = 1, }; // string message = 1 [(.google.api.field_behavior) = REQUIRED]; void clear_message() ; const std::string& message() const; template void set_message(Arg_&& arg, Args_... args); std::string* mutable_message(); PROTOBUF_NODISCARD std::string* release_message(); void set_allocated_message(std::string* ptr); private: const std::string& _internal_message() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_message( const std::string& value); std::string* _internal_mutable_message(); public: // @@protoc_insertion_point(class_scope:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.Error.UnknownError) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_keyapis_2ftelemetry_5fcontrol_2fv1_2fkeyapis_5ftelemetry_5fcontrol_5fstream_5fv1_2eproto; };// ------------------------------------------------------------------- class PostResourceFullDuplexRequest_ResourceAsyncStatus_Error final : public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.Error) */ { public: inline PostResourceFullDuplexRequest_ResourceAsyncStatus_Error() : PostResourceFullDuplexRequest_ResourceAsyncStatus_Error(nullptr) {} ~PostResourceFullDuplexRequest_ResourceAsyncStatus_Error() override; template explicit PROTOBUF_CONSTEXPR PostResourceFullDuplexRequest_ResourceAsyncStatus_Error(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); PostResourceFullDuplexRequest_ResourceAsyncStatus_Error(const PostResourceFullDuplexRequest_ResourceAsyncStatus_Error& from); PostResourceFullDuplexRequest_ResourceAsyncStatus_Error(PostResourceFullDuplexRequest_ResourceAsyncStatus_Error&& from) noexcept : PostResourceFullDuplexRequest_ResourceAsyncStatus_Error() { *this = ::std::move(from); } inline PostResourceFullDuplexRequest_ResourceAsyncStatus_Error& operator=(const PostResourceFullDuplexRequest_ResourceAsyncStatus_Error& from) { CopyFrom(from); return *this; } inline PostResourceFullDuplexRequest_ResourceAsyncStatus_Error& operator=(PostResourceFullDuplexRequest_ResourceAsyncStatus_Error&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const std::string& unknown_fields() const { return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); } inline std::string* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields(); } static const PostResourceFullDuplexRequest_ResourceAsyncStatus_Error& default_instance() { return *internal_default_instance(); } enum ReasonCase { kUnknown = 1, REASON_NOT_SET = 0, }; static inline const PostResourceFullDuplexRequest_ResourceAsyncStatus_Error* internal_default_instance() { return reinterpret_cast( &_PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_default_instance_); } static constexpr int kIndexInFileMessages = 7; friend void swap(PostResourceFullDuplexRequest_ResourceAsyncStatus_Error& a, PostResourceFullDuplexRequest_ResourceAsyncStatus_Error& b) { a.Swap(&b); } inline void Swap(PostResourceFullDuplexRequest_ResourceAsyncStatus_Error* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PostResourceFullDuplexRequest_ResourceAsyncStatus_Error* other) { if (other == this) return; ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PostResourceFullDuplexRequest_ResourceAsyncStatus_Error* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; void CopyFrom(const PostResourceFullDuplexRequest_ResourceAsyncStatus_Error& from); void MergeFrom(const PostResourceFullDuplexRequest_ResourceAsyncStatus_Error& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); void SharedDtor(); void SetCachedSize(int size) const; void InternalSwap(PostResourceFullDuplexRequest_ResourceAsyncStatus_Error* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.Error"; } protected: explicit PostResourceFullDuplexRequest_ResourceAsyncStatus_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: std::string GetTypeName() const final; // nested types ---------------------------------------------------- typedef PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError UnknownError; // accessors ------------------------------------------------------- enum : int { kUnknownFieldNumber = 1, }; // .keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.Error.UnknownError unknown = 1; bool has_unknown() const; private: bool _internal_has_unknown() const; public: void clear_unknown() ; const ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError& unknown() const; PROTOBUF_NODISCARD ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError* release_unknown(); ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError* mutable_unknown(); void set_allocated_unknown(::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError* unknown); private: const ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError& _internal_unknown() const; ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError* _internal_mutable_unknown(); public: void unsafe_arena_set_allocated_unknown( ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError* unknown); ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError* unsafe_arena_release_unknown(); void clear_reason(); ReasonCase reason_case() const; // @@protoc_insertion_point(class_scope:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.Error) private: class _Internal; void set_has_unknown(); inline bool has_reason() const; inline void clear_has_reason(); template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { union ReasonUnion { constexpr ReasonUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError* unknown_; } reason_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::uint32_t _oneof_case_[1]; }; union { Impl_ _impl_; }; friend struct ::TableStruct_keyapis_2ftelemetry_5fcontrol_2fv1_2fkeyapis_5ftelemetry_5fcontrol_5fstream_5fv1_2eproto; };// ------------------------------------------------------------------- class PostResourceFullDuplexRequest_ResourceAsyncStatus final : public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus) */ { public: inline PostResourceFullDuplexRequest_ResourceAsyncStatus() : PostResourceFullDuplexRequest_ResourceAsyncStatus(nullptr) {} ~PostResourceFullDuplexRequest_ResourceAsyncStatus() override; template explicit PROTOBUF_CONSTEXPR PostResourceFullDuplexRequest_ResourceAsyncStatus(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); PostResourceFullDuplexRequest_ResourceAsyncStatus(const PostResourceFullDuplexRequest_ResourceAsyncStatus& from); PostResourceFullDuplexRequest_ResourceAsyncStatus(PostResourceFullDuplexRequest_ResourceAsyncStatus&& from) noexcept : PostResourceFullDuplexRequest_ResourceAsyncStatus() { *this = ::std::move(from); } inline PostResourceFullDuplexRequest_ResourceAsyncStatus& operator=(const PostResourceFullDuplexRequest_ResourceAsyncStatus& from) { CopyFrom(from); return *this; } inline PostResourceFullDuplexRequest_ResourceAsyncStatus& operator=(PostResourceFullDuplexRequest_ResourceAsyncStatus&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const std::string& unknown_fields() const { return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); } inline std::string* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields(); } static const PostResourceFullDuplexRequest_ResourceAsyncStatus& default_instance() { return *internal_default_instance(); } enum TypeCase { kData = 2, kError = 3, TYPE_NOT_SET = 0, }; static inline const PostResourceFullDuplexRequest_ResourceAsyncStatus* internal_default_instance() { return reinterpret_cast( &_PostResourceFullDuplexRequest_ResourceAsyncStatus_default_instance_); } static constexpr int kIndexInFileMessages = 8; friend void swap(PostResourceFullDuplexRequest_ResourceAsyncStatus& a, PostResourceFullDuplexRequest_ResourceAsyncStatus& b) { a.Swap(&b); } inline void Swap(PostResourceFullDuplexRequest_ResourceAsyncStatus* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PostResourceFullDuplexRequest_ResourceAsyncStatus* other) { if (other == this) return; ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PostResourceFullDuplexRequest_ResourceAsyncStatus* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; void CopyFrom(const PostResourceFullDuplexRequest_ResourceAsyncStatus& from); void MergeFrom(const PostResourceFullDuplexRequest_ResourceAsyncStatus& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); void SharedDtor(); void SetCachedSize(int size) const; void InternalSwap(PostResourceFullDuplexRequest_ResourceAsyncStatus* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus"; } protected: explicit PostResourceFullDuplexRequest_ResourceAsyncStatus(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: std::string GetTypeName() const final; // nested types ---------------------------------------------------- typedef PostResourceFullDuplexRequest_ResourceAsyncStatus_Success Success; typedef PostResourceFullDuplexRequest_ResourceAsyncStatus_Error Error; // accessors ------------------------------------------------------- enum : int { kResourceIdFieldNumber = 1, kDataFieldNumber = 2, kErrorFieldNumber = 3, }; // .keyapis.telemetry_control.v1.ResourceId resource_id = 1 [(.google.api.field_behavior) = REQUIRED]; bool has_resource_id() const; void clear_resource_id() ; const ::keyapis::telemetry_control::v1::ResourceId& resource_id() const; PROTOBUF_NODISCARD ::keyapis::telemetry_control::v1::ResourceId* release_resource_id(); ::keyapis::telemetry_control::v1::ResourceId* mutable_resource_id(); void set_allocated_resource_id(::keyapis::telemetry_control::v1::ResourceId* resource_id); private: const ::keyapis::telemetry_control::v1::ResourceId& _internal_resource_id() const; ::keyapis::telemetry_control::v1::ResourceId* _internal_mutable_resource_id(); public: void unsafe_arena_set_allocated_resource_id( ::keyapis::telemetry_control::v1::ResourceId* resource_id); ::keyapis::telemetry_control::v1::ResourceId* unsafe_arena_release_resource_id(); // .keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.Success data = 2; bool has_data() const; private: bool _internal_has_data() const; public: void clear_data() ; const ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Success& data() const; PROTOBUF_NODISCARD ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Success* release_data(); ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Success* mutable_data(); void set_allocated_data(::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Success* data); private: const ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Success& _internal_data() const; ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Success* _internal_mutable_data(); public: void unsafe_arena_set_allocated_data( ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Success* data); ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Success* unsafe_arena_release_data(); // .keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.Error error = 3; bool has_error() const; private: bool _internal_has_error() const; public: void clear_error() ; const ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error& error() const; PROTOBUF_NODISCARD ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error* release_error(); ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error* mutable_error(); void set_allocated_error(::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error* error); private: const ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error& _internal_error() const; ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error* _internal_mutable_error(); public: void unsafe_arena_set_allocated_error( ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error* error); ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error* unsafe_arena_release_error(); void clear_type(); TypeCase type_case() const; // @@protoc_insertion_point(class_scope:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus) private: class _Internal; void set_has_data(); void set_has_error(); inline bool has_type() const; inline void clear_has_type(); template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::keyapis::telemetry_control::v1::ResourceId* resource_id_; union TypeUnion { constexpr TypeUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Success* data_; ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error* error_; } type_; ::uint32_t _oneof_case_[1]; }; union { Impl_ _impl_; }; friend struct ::TableStruct_keyapis_2ftelemetry_5fcontrol_2fv1_2fkeyapis_5ftelemetry_5fcontrol_5fstream_5fv1_2eproto; };// ------------------------------------------------------------------- class PostResourceFullDuplexRequest final : public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest) */ { public: inline PostResourceFullDuplexRequest() : PostResourceFullDuplexRequest(nullptr) {} ~PostResourceFullDuplexRequest() override; template explicit PROTOBUF_CONSTEXPR PostResourceFullDuplexRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); PostResourceFullDuplexRequest(const PostResourceFullDuplexRequest& from); PostResourceFullDuplexRequest(PostResourceFullDuplexRequest&& from) noexcept : PostResourceFullDuplexRequest() { *this = ::std::move(from); } inline PostResourceFullDuplexRequest& operator=(const PostResourceFullDuplexRequest& from) { CopyFrom(from); return *this; } inline PostResourceFullDuplexRequest& operator=(PostResourceFullDuplexRequest&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const std::string& unknown_fields() const { return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); } inline std::string* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields(); } static const PostResourceFullDuplexRequest& default_instance() { return *internal_default_instance(); } enum TaskCase { kResourceAsyncStatus = 2, TASK_NOT_SET = 0, }; static inline const PostResourceFullDuplexRequest* internal_default_instance() { return reinterpret_cast( &_PostResourceFullDuplexRequest_default_instance_); } static constexpr int kIndexInFileMessages = 9; friend void swap(PostResourceFullDuplexRequest& a, PostResourceFullDuplexRequest& b) { a.Swap(&b); } inline void Swap(PostResourceFullDuplexRequest* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PostResourceFullDuplexRequest* other) { if (other == this) return; ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PostResourceFullDuplexRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; void CopyFrom(const PostResourceFullDuplexRequest& from); void MergeFrom(const PostResourceFullDuplexRequest& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; ::size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::uint8_t* _InternalSerialize( ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); void SharedDtor(); void SetCachedSize(int size) const; void InternalSwap(PostResourceFullDuplexRequest* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::absl::string_view FullMessageName() { return "keyapis.telemetry_control.v1.PostResourceFullDuplexRequest"; } protected: explicit PostResourceFullDuplexRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: std::string GetTypeName() const final; // nested types ---------------------------------------------------- typedef PostResourceFullDuplexRequest_ResourceAsyncStatus ResourceAsyncStatus; // accessors ------------------------------------------------------- enum : int { kRequestIdFieldNumber = 1, kResourceAsyncStatusFieldNumber = 2, }; // string request_id = 1; void clear_request_id() ; const std::string& request_id() const; template void set_request_id(Arg_&& arg, Args_... args); std::string* mutable_request_id(); PROTOBUF_NODISCARD std::string* release_request_id(); void set_allocated_request_id(std::string* ptr); private: const std::string& _internal_request_id() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_request_id( const std::string& value); std::string* _internal_mutable_request_id(); public: // .keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus resource_async_status = 2; bool has_resource_async_status() const; private: bool _internal_has_resource_async_status() const; public: void clear_resource_async_status() ; const ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus& resource_async_status() const; PROTOBUF_NODISCARD ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus* release_resource_async_status(); ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus* mutable_resource_async_status(); void set_allocated_resource_async_status(::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus* resource_async_status); private: const ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus& _internal_resource_async_status() const; ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus* _internal_mutable_resource_async_status(); public: void unsafe_arena_set_allocated_resource_async_status( ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus* resource_async_status); ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus* unsafe_arena_release_resource_async_status(); void clear_task(); TaskCase task_case() const; // @@protoc_insertion_point(class_scope:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest) private: class _Internal; void set_has_resource_async_status(); inline bool has_task() const; inline void clear_has_task(); template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_id_; union TaskUnion { constexpr TaskUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus* resource_async_status_; } task_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::uint32_t _oneof_case_[1]; }; union { Impl_ _impl_; }; friend struct ::TableStruct_keyapis_2ftelemetry_5fcontrol_2fv1_2fkeyapis_5ftelemetry_5fcontrol_5fstream_5fv1_2eproto; }; // =================================================================== // =================================================================== #ifdef __GNUC__ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wstrict-aliasing" #endif // __GNUC__ // ------------------------------------------------------------------- // PostResourceFullDuplexResponse_RemoveResourceEvent // .keyapis.telemetry_control.v1.ResourceId resource_id = 1 [(.google.api.field_behavior) = REQUIRED]; inline bool PostResourceFullDuplexResponse_RemoveResourceEvent::has_resource_id() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.resource_id_ != nullptr); return value; } inline void PostResourceFullDuplexResponse_RemoveResourceEvent::clear_resource_id() { if (_impl_.resource_id_ != nullptr) _impl_.resource_id_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } inline const ::keyapis::telemetry_control::v1::ResourceId& PostResourceFullDuplexResponse_RemoveResourceEvent::_internal_resource_id() const { const ::keyapis::telemetry_control::v1::ResourceId* p = _impl_.resource_id_; return p != nullptr ? *p : reinterpret_cast( ::keyapis::telemetry_control::v1::_ResourceId_default_instance_); } inline const ::keyapis::telemetry_control::v1::ResourceId& PostResourceFullDuplexResponse_RemoveResourceEvent::resource_id() const { // @@protoc_insertion_point(field_get:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.RemoveResourceEvent.resource_id) return _internal_resource_id(); } inline void PostResourceFullDuplexResponse_RemoveResourceEvent::unsafe_arena_set_allocated_resource_id( ::keyapis::telemetry_control::v1::ResourceId* resource_id) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.resource_id_); } _impl_.resource_id_ = resource_id; if (resource_id) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.RemoveResourceEvent.resource_id) } inline ::keyapis::telemetry_control::v1::ResourceId* PostResourceFullDuplexResponse_RemoveResourceEvent::release_resource_id() { _impl_._has_bits_[0] &= ~0x00000001u; ::keyapis::telemetry_control::v1::ResourceId* temp = _impl_.resource_id_; _impl_.resource_id_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::keyapis::telemetry_control::v1::ResourceId* PostResourceFullDuplexResponse_RemoveResourceEvent::unsafe_arena_release_resource_id() { // @@protoc_insertion_point(field_release:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.RemoveResourceEvent.resource_id) _impl_._has_bits_[0] &= ~0x00000001u; ::keyapis::telemetry_control::v1::ResourceId* temp = _impl_.resource_id_; _impl_.resource_id_ = nullptr; return temp; } inline ::keyapis::telemetry_control::v1::ResourceId* PostResourceFullDuplexResponse_RemoveResourceEvent::_internal_mutable_resource_id() { _impl_._has_bits_[0] |= 0x00000001u; if (_impl_.resource_id_ == nullptr) { auto* p = CreateMaybeMessage<::keyapis::telemetry_control::v1::ResourceId>(GetArenaForAllocation()); _impl_.resource_id_ = p; } return _impl_.resource_id_; } inline ::keyapis::telemetry_control::v1::ResourceId* PostResourceFullDuplexResponse_RemoveResourceEvent::mutable_resource_id() { ::keyapis::telemetry_control::v1::ResourceId* _msg = _internal_mutable_resource_id(); // @@protoc_insertion_point(field_mutable:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.RemoveResourceEvent.resource_id) return _msg; } inline void PostResourceFullDuplexResponse_RemoveResourceEvent::set_allocated_resource_id(::keyapis::telemetry_control::v1::ResourceId* resource_id) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.resource_id_; } if (resource_id) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(resource_id); if (message_arena != submessage_arena) { resource_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, resource_id, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.resource_id_ = resource_id; // @@protoc_insertion_point(field_set_allocated:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.RemoveResourceEvent.resource_id) } // ------------------------------------------------------------------- // PostResourceFullDuplexResponse_UpsertResourceEvent // .keyapis.telemetry_control.v1.Resource resource = 1 [(.google.api.field_behavior) = REQUIRED]; inline bool PostResourceFullDuplexResponse_UpsertResourceEvent::has_resource() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.resource_ != nullptr); return value; } inline void PostResourceFullDuplexResponse_UpsertResourceEvent::clear_resource() { if (_impl_.resource_ != nullptr) _impl_.resource_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } inline const ::keyapis::telemetry_control::v1::Resource& PostResourceFullDuplexResponse_UpsertResourceEvent::_internal_resource() const { const ::keyapis::telemetry_control::v1::Resource* p = _impl_.resource_; return p != nullptr ? *p : reinterpret_cast( ::keyapis::telemetry_control::v1::_Resource_default_instance_); } inline const ::keyapis::telemetry_control::v1::Resource& PostResourceFullDuplexResponse_UpsertResourceEvent::resource() const { // @@protoc_insertion_point(field_get:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.UpsertResourceEvent.resource) return _internal_resource(); } inline void PostResourceFullDuplexResponse_UpsertResourceEvent::unsafe_arena_set_allocated_resource( ::keyapis::telemetry_control::v1::Resource* resource) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.resource_); } _impl_.resource_ = resource; if (resource) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.UpsertResourceEvent.resource) } inline ::keyapis::telemetry_control::v1::Resource* PostResourceFullDuplexResponse_UpsertResourceEvent::release_resource() { _impl_._has_bits_[0] &= ~0x00000001u; ::keyapis::telemetry_control::v1::Resource* temp = _impl_.resource_; _impl_.resource_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::keyapis::telemetry_control::v1::Resource* PostResourceFullDuplexResponse_UpsertResourceEvent::unsafe_arena_release_resource() { // @@protoc_insertion_point(field_release:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.UpsertResourceEvent.resource) _impl_._has_bits_[0] &= ~0x00000001u; ::keyapis::telemetry_control::v1::Resource* temp = _impl_.resource_; _impl_.resource_ = nullptr; return temp; } inline ::keyapis::telemetry_control::v1::Resource* PostResourceFullDuplexResponse_UpsertResourceEvent::_internal_mutable_resource() { _impl_._has_bits_[0] |= 0x00000001u; if (_impl_.resource_ == nullptr) { auto* p = CreateMaybeMessage<::keyapis::telemetry_control::v1::Resource>(GetArenaForAllocation()); _impl_.resource_ = p; } return _impl_.resource_; } inline ::keyapis::telemetry_control::v1::Resource* PostResourceFullDuplexResponse_UpsertResourceEvent::mutable_resource() { ::keyapis::telemetry_control::v1::Resource* _msg = _internal_mutable_resource(); // @@protoc_insertion_point(field_mutable:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.UpsertResourceEvent.resource) return _msg; } inline void PostResourceFullDuplexResponse_UpsertResourceEvent::set_allocated_resource(::keyapis::telemetry_control::v1::Resource* resource) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.resource_; } if (resource) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(resource); if (message_arena != submessage_arena) { resource = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, resource, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.resource_ = resource; // @@protoc_insertion_point(field_set_allocated:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.UpsertResourceEvent.resource) } // ------------------------------------------------------------------- // PostResourceFullDuplexResponse // string request_id = 1 [(.google.api.field_behavior) = REQUIRED]; inline void PostResourceFullDuplexResponse::clear_request_id() { _impl_.request_id_.ClearToEmpty(); } inline const std::string& PostResourceFullDuplexResponse::request_id() const { // @@protoc_insertion_point(field_get:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.request_id) return _internal_request_id(); } template inline PROTOBUF_ALWAYS_INLINE void PostResourceFullDuplexResponse::set_request_id(Arg_&& arg, Args_... args) { ; _impl_.request_id_.Set(static_cast(arg), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.request_id) } inline std::string* PostResourceFullDuplexResponse::mutable_request_id() { std::string* _s = _internal_mutable_request_id(); // @@protoc_insertion_point(field_mutable:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.request_id) return _s; } inline const std::string& PostResourceFullDuplexResponse::_internal_request_id() const { return _impl_.request_id_.Get(); } inline void PostResourceFullDuplexResponse::_internal_set_request_id(const std::string& value) { ; _impl_.request_id_.Set(value, GetArenaForAllocation()); } inline std::string* PostResourceFullDuplexResponse::_internal_mutable_request_id() { ; return _impl_.request_id_.Mutable( GetArenaForAllocation()); } inline std::string* PostResourceFullDuplexResponse::release_request_id() { // @@protoc_insertion_point(field_release:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.request_id) return _impl_.request_id_.Release(); } inline void PostResourceFullDuplexResponse::set_allocated_request_id(std::string* value) { _impl_.request_id_.SetAllocated(value, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.request_id_.IsDefault()) { _impl_.request_id_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.request_id) } // .keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.UpsertResourceEvent upsert_resource_event = 2; inline bool PostResourceFullDuplexResponse::has_upsert_resource_event() const { return event_case() == kUpsertResourceEvent; } inline bool PostResourceFullDuplexResponse::_internal_has_upsert_resource_event() const { return event_case() == kUpsertResourceEvent; } inline void PostResourceFullDuplexResponse::set_has_upsert_resource_event() { _impl_._oneof_case_[0] = kUpsertResourceEvent; } inline void PostResourceFullDuplexResponse::clear_upsert_resource_event() { if (event_case() == kUpsertResourceEvent) { if (GetArenaForAllocation() == nullptr) { delete _impl_.event_.upsert_resource_event_; } clear_has_event(); } } inline ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_UpsertResourceEvent* PostResourceFullDuplexResponse::release_upsert_resource_event() { // @@protoc_insertion_point(field_release:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.upsert_resource_event) if (event_case() == kUpsertResourceEvent) { clear_has_event(); ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_UpsertResourceEvent* temp = _impl_.event_.upsert_resource_event_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.event_.upsert_resource_event_ = nullptr; return temp; } else { return nullptr; } } inline const ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_UpsertResourceEvent& PostResourceFullDuplexResponse::_internal_upsert_resource_event() const { return event_case() == kUpsertResourceEvent ? *_impl_.event_.upsert_resource_event_ : reinterpret_cast<::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_UpsertResourceEvent&>(::keyapis::telemetry_control::v1::_PostResourceFullDuplexResponse_UpsertResourceEvent_default_instance_); } inline const ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_UpsertResourceEvent& PostResourceFullDuplexResponse::upsert_resource_event() const { // @@protoc_insertion_point(field_get:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.upsert_resource_event) return _internal_upsert_resource_event(); } inline ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_UpsertResourceEvent* PostResourceFullDuplexResponse::unsafe_arena_release_upsert_resource_event() { // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.upsert_resource_event) if (event_case() == kUpsertResourceEvent) { clear_has_event(); ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_UpsertResourceEvent* temp = _impl_.event_.upsert_resource_event_; _impl_.event_.upsert_resource_event_ = nullptr; return temp; } else { return nullptr; } } inline void PostResourceFullDuplexResponse::unsafe_arena_set_allocated_upsert_resource_event(::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_UpsertResourceEvent* upsert_resource_event) { clear_event(); if (upsert_resource_event) { set_has_upsert_resource_event(); _impl_.event_.upsert_resource_event_ = upsert_resource_event; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.upsert_resource_event) } inline ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_UpsertResourceEvent* PostResourceFullDuplexResponse::_internal_mutable_upsert_resource_event() { if (event_case() != kUpsertResourceEvent) { clear_event(); set_has_upsert_resource_event(); _impl_.event_.upsert_resource_event_ = CreateMaybeMessage< ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_UpsertResourceEvent >(GetArenaForAllocation()); } return _impl_.event_.upsert_resource_event_; } inline ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_UpsertResourceEvent* PostResourceFullDuplexResponse::mutable_upsert_resource_event() { ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_UpsertResourceEvent* _msg = _internal_mutable_upsert_resource_event(); // @@protoc_insertion_point(field_mutable:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.upsert_resource_event) return _msg; } // .keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.RemoveResourceEvent remove_resource_event = 3; inline bool PostResourceFullDuplexResponse::has_remove_resource_event() const { return event_case() == kRemoveResourceEvent; } inline bool PostResourceFullDuplexResponse::_internal_has_remove_resource_event() const { return event_case() == kRemoveResourceEvent; } inline void PostResourceFullDuplexResponse::set_has_remove_resource_event() { _impl_._oneof_case_[0] = kRemoveResourceEvent; } inline void PostResourceFullDuplexResponse::clear_remove_resource_event() { if (event_case() == kRemoveResourceEvent) { if (GetArenaForAllocation() == nullptr) { delete _impl_.event_.remove_resource_event_; } clear_has_event(); } } inline ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_RemoveResourceEvent* PostResourceFullDuplexResponse::release_remove_resource_event() { // @@protoc_insertion_point(field_release:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.remove_resource_event) if (event_case() == kRemoveResourceEvent) { clear_has_event(); ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_RemoveResourceEvent* temp = _impl_.event_.remove_resource_event_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.event_.remove_resource_event_ = nullptr; return temp; } else { return nullptr; } } inline const ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_RemoveResourceEvent& PostResourceFullDuplexResponse::_internal_remove_resource_event() const { return event_case() == kRemoveResourceEvent ? *_impl_.event_.remove_resource_event_ : reinterpret_cast<::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_RemoveResourceEvent&>(::keyapis::telemetry_control::v1::_PostResourceFullDuplexResponse_RemoveResourceEvent_default_instance_); } inline const ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_RemoveResourceEvent& PostResourceFullDuplexResponse::remove_resource_event() const { // @@protoc_insertion_point(field_get:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.remove_resource_event) return _internal_remove_resource_event(); } inline ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_RemoveResourceEvent* PostResourceFullDuplexResponse::unsafe_arena_release_remove_resource_event() { // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.remove_resource_event) if (event_case() == kRemoveResourceEvent) { clear_has_event(); ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_RemoveResourceEvent* temp = _impl_.event_.remove_resource_event_; _impl_.event_.remove_resource_event_ = nullptr; return temp; } else { return nullptr; } } inline void PostResourceFullDuplexResponse::unsafe_arena_set_allocated_remove_resource_event(::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_RemoveResourceEvent* remove_resource_event) { clear_event(); if (remove_resource_event) { set_has_remove_resource_event(); _impl_.event_.remove_resource_event_ = remove_resource_event; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.remove_resource_event) } inline ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_RemoveResourceEvent* PostResourceFullDuplexResponse::_internal_mutable_remove_resource_event() { if (event_case() != kRemoveResourceEvent) { clear_event(); set_has_remove_resource_event(); _impl_.event_.remove_resource_event_ = CreateMaybeMessage< ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_RemoveResourceEvent >(GetArenaForAllocation()); } return _impl_.event_.remove_resource_event_; } inline ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_RemoveResourceEvent* PostResourceFullDuplexResponse::mutable_remove_resource_event() { ::keyapis::telemetry_control::v1::PostResourceFullDuplexResponse_RemoveResourceEvent* _msg = _internal_mutable_remove_resource_event(); // @@protoc_insertion_point(field_mutable:keyapis.telemetry_control.v1.PostResourceFullDuplexResponse.remove_resource_event) return _msg; } inline bool PostResourceFullDuplexResponse::has_event() const { return event_case() != EVENT_NOT_SET; } inline void PostResourceFullDuplexResponse::clear_has_event() { _impl_._oneof_case_[0] = EVENT_NOT_SET; } inline PostResourceFullDuplexResponse::EventCase PostResourceFullDuplexResponse::event_case() const { return PostResourceFullDuplexResponse::EventCase(_impl_._oneof_case_[0]); } // ------------------------------------------------------------------- // ResourceId // int32 building_id = 1; inline bool ResourceId::has_building_id() const { return type_case() == kBuildingId; } inline void ResourceId::set_has_building_id() { _impl_._oneof_case_[0] = kBuildingId; } inline void ResourceId::clear_building_id() { if (type_case() == kBuildingId) { _impl_.type_.building_id_ = 0; clear_has_type(); } } inline ::int32_t ResourceId::building_id() const { // @@protoc_insertion_point(field_get:keyapis.telemetry_control.v1.ResourceId.building_id) return _internal_building_id(); } inline void ResourceId::set_building_id(::int32_t value) { _internal_set_building_id(value); // @@protoc_insertion_point(field_set:keyapis.telemetry_control.v1.ResourceId.building_id) } inline ::int32_t ResourceId::_internal_building_id() const { if (type_case() == kBuildingId) { return _impl_.type_.building_id_; } return 0; } inline void ResourceId::_internal_set_building_id(::int32_t value) { if (type_case() != kBuildingId) { clear_type(); set_has_building_id(); } _impl_.type_.building_id_ = value; } // int32 device_id = 2; inline bool ResourceId::has_device_id() const { return type_case() == kDeviceId; } inline void ResourceId::set_has_device_id() { _impl_._oneof_case_[0] = kDeviceId; } inline void ResourceId::clear_device_id() { if (type_case() == kDeviceId) { _impl_.type_.device_id_ = 0; clear_has_type(); } } inline ::int32_t ResourceId::device_id() const { // @@protoc_insertion_point(field_get:keyapis.telemetry_control.v1.ResourceId.device_id) return _internal_device_id(); } inline void ResourceId::set_device_id(::int32_t value) { _internal_set_device_id(value); // @@protoc_insertion_point(field_set:keyapis.telemetry_control.v1.ResourceId.device_id) } inline ::int32_t ResourceId::_internal_device_id() const { if (type_case() == kDeviceId) { return _impl_.type_.device_id_; } return 0; } inline void ResourceId::_internal_set_device_id(::int32_t value) { if (type_case() != kDeviceId) { clear_type(); set_has_device_id(); } _impl_.type_.device_id_ = value; } // string metric_point_id = 3; inline bool ResourceId::has_metric_point_id() const { return type_case() == kMetricPointId; } inline void ResourceId::set_has_metric_point_id() { _impl_._oneof_case_[0] = kMetricPointId; } inline void ResourceId::clear_metric_point_id() { if (type_case() == kMetricPointId) { _impl_.type_.metric_point_id_.Destroy(); clear_has_type(); } } inline const std::string& ResourceId::metric_point_id() const { // @@protoc_insertion_point(field_get:keyapis.telemetry_control.v1.ResourceId.metric_point_id) return _internal_metric_point_id(); } template inline PROTOBUF_ALWAYS_INLINE void ResourceId::set_metric_point_id(Arg_&& arg, Args_... args) { if (type_case() != kMetricPointId) { clear_type(); set_has_metric_point_id(); _impl_.type_.metric_point_id_.InitDefault(); } _impl_.type_.metric_point_id_.Set(static_cast(arg), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:keyapis.telemetry_control.v1.ResourceId.metric_point_id) } inline std::string* ResourceId::mutable_metric_point_id() { std::string* _s = _internal_mutable_metric_point_id(); // @@protoc_insertion_point(field_mutable:keyapis.telemetry_control.v1.ResourceId.metric_point_id) return _s; } inline const std::string& ResourceId::_internal_metric_point_id() const { if (type_case() != kMetricPointId) { return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); } return _impl_.type_.metric_point_id_.Get(); } inline void ResourceId::_internal_set_metric_point_id(const std::string& value) { if (type_case() != kMetricPointId) { clear_type(); set_has_metric_point_id(); _impl_.type_.metric_point_id_.InitDefault(); } _impl_.type_.metric_point_id_.Set(value, GetArenaForAllocation()); } inline std::string* ResourceId::_internal_mutable_metric_point_id() { if (type_case() != kMetricPointId) { clear_type(); set_has_metric_point_id(); _impl_.type_.metric_point_id_.InitDefault(); } return _impl_.type_.metric_point_id_.Mutable( GetArenaForAllocation()); } inline std::string* ResourceId::release_metric_point_id() { // @@protoc_insertion_point(field_release:keyapis.telemetry_control.v1.ResourceId.metric_point_id) if (type_case() != kMetricPointId) { return nullptr; } clear_has_type(); return _impl_.type_.metric_point_id_.Release(); } inline void ResourceId::set_allocated_metric_point_id(std::string* value) { if (has_type()) { clear_type(); } if (value != nullptr) { set_has_metric_point_id(); _impl_.type_.metric_point_id_.InitAllocated(value, GetArenaForAllocation()); } // @@protoc_insertion_point(field_set_allocated:keyapis.telemetry_control.v1.ResourceId.metric_point_id) } // int32 indicator_id = 4; inline bool ResourceId::has_indicator_id() const { return type_case() == kIndicatorId; } inline void ResourceId::set_has_indicator_id() { _impl_._oneof_case_[0] = kIndicatorId; } inline void ResourceId::clear_indicator_id() { if (type_case() == kIndicatorId) { _impl_.type_.indicator_id_ = 0; clear_has_type(); } } inline ::int32_t ResourceId::indicator_id() const { // @@protoc_insertion_point(field_get:keyapis.telemetry_control.v1.ResourceId.indicator_id) return _internal_indicator_id(); } inline void ResourceId::set_indicator_id(::int32_t value) { _internal_set_indicator_id(value); // @@protoc_insertion_point(field_set:keyapis.telemetry_control.v1.ResourceId.indicator_id) } inline ::int32_t ResourceId::_internal_indicator_id() const { if (type_case() == kIndicatorId) { return _impl_.type_.indicator_id_; } return 0; } inline void ResourceId::_internal_set_indicator_id(::int32_t value) { if (type_case() != kIndicatorId) { clear_type(); set_has_indicator_id(); } _impl_.type_.indicator_id_ = value; } // .keyapis.telemetry_control.v1.DeviceIndicatorMetricPoint indicator_metric_point = 5; inline bool ResourceId::has_indicator_metric_point() const { return type_case() == kIndicatorMetricPoint; } inline bool ResourceId::_internal_has_indicator_metric_point() const { return type_case() == kIndicatorMetricPoint; } inline void ResourceId::set_has_indicator_metric_point() { _impl_._oneof_case_[0] = kIndicatorMetricPoint; } inline ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* ResourceId::release_indicator_metric_point() { // @@protoc_insertion_point(field_release:keyapis.telemetry_control.v1.ResourceId.indicator_metric_point) if (type_case() == kIndicatorMetricPoint) { clear_has_type(); ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* temp = _impl_.type_.indicator_metric_point_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.type_.indicator_metric_point_ = nullptr; return temp; } else { return nullptr; } } inline const ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint& ResourceId::_internal_indicator_metric_point() const { return type_case() == kIndicatorMetricPoint ? *_impl_.type_.indicator_metric_point_ : reinterpret_cast<::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint&>(::keyapis::telemetry_control::v1::_DeviceIndicatorMetricPoint_default_instance_); } inline const ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint& ResourceId::indicator_metric_point() const { // @@protoc_insertion_point(field_get:keyapis.telemetry_control.v1.ResourceId.indicator_metric_point) return _internal_indicator_metric_point(); } inline ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* ResourceId::unsafe_arena_release_indicator_metric_point() { // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.telemetry_control.v1.ResourceId.indicator_metric_point) if (type_case() == kIndicatorMetricPoint) { clear_has_type(); ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* temp = _impl_.type_.indicator_metric_point_; _impl_.type_.indicator_metric_point_ = nullptr; return temp; } else { return nullptr; } } inline void ResourceId::unsafe_arena_set_allocated_indicator_metric_point(::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* indicator_metric_point) { clear_type(); if (indicator_metric_point) { set_has_indicator_metric_point(); _impl_.type_.indicator_metric_point_ = indicator_metric_point; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.telemetry_control.v1.ResourceId.indicator_metric_point) } inline ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* ResourceId::_internal_mutable_indicator_metric_point() { if (type_case() != kIndicatorMetricPoint) { clear_type(); set_has_indicator_metric_point(); _impl_.type_.indicator_metric_point_ = CreateMaybeMessage< ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint >(GetArenaForAllocation()); } return _impl_.type_.indicator_metric_point_; } inline ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* ResourceId::mutable_indicator_metric_point() { ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* _msg = _internal_mutable_indicator_metric_point(); // @@protoc_insertion_point(field_mutable:keyapis.telemetry_control.v1.ResourceId.indicator_metric_point) return _msg; } inline bool ResourceId::has_type() const { return type_case() != TYPE_NOT_SET; } inline void ResourceId::clear_has_type() { _impl_._oneof_case_[0] = TYPE_NOT_SET; } inline ResourceId::TypeCase ResourceId::type_case() const { return ResourceId::TypeCase(_impl_._oneof_case_[0]); } // ------------------------------------------------------------------- // Resource // .keyapis.telemetry_control.v1.Building building = 1; inline bool Resource::has_building() const { return type_case() == kBuilding; } inline bool Resource::_internal_has_building() const { return type_case() == kBuilding; } inline void Resource::set_has_building() { _impl_._oneof_case_[0] = kBuilding; } inline ::keyapis::telemetry_control::v1::Building* Resource::release_building() { // @@protoc_insertion_point(field_release:keyapis.telemetry_control.v1.Resource.building) if (type_case() == kBuilding) { clear_has_type(); ::keyapis::telemetry_control::v1::Building* temp = _impl_.type_.building_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.type_.building_ = nullptr; return temp; } else { return nullptr; } } inline const ::keyapis::telemetry_control::v1::Building& Resource::_internal_building() const { return type_case() == kBuilding ? *_impl_.type_.building_ : reinterpret_cast<::keyapis::telemetry_control::v1::Building&>(::keyapis::telemetry_control::v1::_Building_default_instance_); } inline const ::keyapis::telemetry_control::v1::Building& Resource::building() const { // @@protoc_insertion_point(field_get:keyapis.telemetry_control.v1.Resource.building) return _internal_building(); } inline ::keyapis::telemetry_control::v1::Building* Resource::unsafe_arena_release_building() { // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.telemetry_control.v1.Resource.building) if (type_case() == kBuilding) { clear_has_type(); ::keyapis::telemetry_control::v1::Building* temp = _impl_.type_.building_; _impl_.type_.building_ = nullptr; return temp; } else { return nullptr; } } inline void Resource::unsafe_arena_set_allocated_building(::keyapis::telemetry_control::v1::Building* building) { clear_type(); if (building) { set_has_building(); _impl_.type_.building_ = building; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.telemetry_control.v1.Resource.building) } inline ::keyapis::telemetry_control::v1::Building* Resource::_internal_mutable_building() { if (type_case() != kBuilding) { clear_type(); set_has_building(); _impl_.type_.building_ = CreateMaybeMessage< ::keyapis::telemetry_control::v1::Building >(GetArenaForAllocation()); } return _impl_.type_.building_; } inline ::keyapis::telemetry_control::v1::Building* Resource::mutable_building() { ::keyapis::telemetry_control::v1::Building* _msg = _internal_mutable_building(); // @@protoc_insertion_point(field_mutable:keyapis.telemetry_control.v1.Resource.building) return _msg; } // .keyapis.telemetry_control.v1.Device device = 2; inline bool Resource::has_device() const { return type_case() == kDevice; } inline bool Resource::_internal_has_device() const { return type_case() == kDevice; } inline void Resource::set_has_device() { _impl_._oneof_case_[0] = kDevice; } inline ::keyapis::telemetry_control::v1::Device* Resource::release_device() { // @@protoc_insertion_point(field_release:keyapis.telemetry_control.v1.Resource.device) if (type_case() == kDevice) { clear_has_type(); ::keyapis::telemetry_control::v1::Device* temp = _impl_.type_.device_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.type_.device_ = nullptr; return temp; } else { return nullptr; } } inline const ::keyapis::telemetry_control::v1::Device& Resource::_internal_device() const { return type_case() == kDevice ? *_impl_.type_.device_ : reinterpret_cast<::keyapis::telemetry_control::v1::Device&>(::keyapis::telemetry_control::v1::_Device_default_instance_); } inline const ::keyapis::telemetry_control::v1::Device& Resource::device() const { // @@protoc_insertion_point(field_get:keyapis.telemetry_control.v1.Resource.device) return _internal_device(); } inline ::keyapis::telemetry_control::v1::Device* Resource::unsafe_arena_release_device() { // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.telemetry_control.v1.Resource.device) if (type_case() == kDevice) { clear_has_type(); ::keyapis::telemetry_control::v1::Device* temp = _impl_.type_.device_; _impl_.type_.device_ = nullptr; return temp; } else { return nullptr; } } inline void Resource::unsafe_arena_set_allocated_device(::keyapis::telemetry_control::v1::Device* device) { clear_type(); if (device) { set_has_device(); _impl_.type_.device_ = device; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.telemetry_control.v1.Resource.device) } inline ::keyapis::telemetry_control::v1::Device* Resource::_internal_mutable_device() { if (type_case() != kDevice) { clear_type(); set_has_device(); _impl_.type_.device_ = CreateMaybeMessage< ::keyapis::telemetry_control::v1::Device >(GetArenaForAllocation()); } return _impl_.type_.device_; } inline ::keyapis::telemetry_control::v1::Device* Resource::mutable_device() { ::keyapis::telemetry_control::v1::Device* _msg = _internal_mutable_device(); // @@protoc_insertion_point(field_mutable:keyapis.telemetry_control.v1.Resource.device) return _msg; } // .keyapis.telemetry_control.v1.Device.MetricPoint metric_point = 3; inline bool Resource::has_metric_point() const { return type_case() == kMetricPoint; } inline bool Resource::_internal_has_metric_point() const { return type_case() == kMetricPoint; } inline void Resource::set_has_metric_point() { _impl_._oneof_case_[0] = kMetricPoint; } inline ::keyapis::telemetry_control::v1::Device_MetricPoint* Resource::release_metric_point() { // @@protoc_insertion_point(field_release:keyapis.telemetry_control.v1.Resource.metric_point) if (type_case() == kMetricPoint) { clear_has_type(); ::keyapis::telemetry_control::v1::Device_MetricPoint* temp = _impl_.type_.metric_point_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.type_.metric_point_ = nullptr; return temp; } else { return nullptr; } } inline const ::keyapis::telemetry_control::v1::Device_MetricPoint& Resource::_internal_metric_point() const { return type_case() == kMetricPoint ? *_impl_.type_.metric_point_ : reinterpret_cast<::keyapis::telemetry_control::v1::Device_MetricPoint&>(::keyapis::telemetry_control::v1::_Device_MetricPoint_default_instance_); } inline const ::keyapis::telemetry_control::v1::Device_MetricPoint& Resource::metric_point() const { // @@protoc_insertion_point(field_get:keyapis.telemetry_control.v1.Resource.metric_point) return _internal_metric_point(); } inline ::keyapis::telemetry_control::v1::Device_MetricPoint* Resource::unsafe_arena_release_metric_point() { // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.telemetry_control.v1.Resource.metric_point) if (type_case() == kMetricPoint) { clear_has_type(); ::keyapis::telemetry_control::v1::Device_MetricPoint* temp = _impl_.type_.metric_point_; _impl_.type_.metric_point_ = nullptr; return temp; } else { return nullptr; } } inline void Resource::unsafe_arena_set_allocated_metric_point(::keyapis::telemetry_control::v1::Device_MetricPoint* metric_point) { clear_type(); if (metric_point) { set_has_metric_point(); _impl_.type_.metric_point_ = metric_point; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.telemetry_control.v1.Resource.metric_point) } inline ::keyapis::telemetry_control::v1::Device_MetricPoint* Resource::_internal_mutable_metric_point() { if (type_case() != kMetricPoint) { clear_type(); set_has_metric_point(); _impl_.type_.metric_point_ = CreateMaybeMessage< ::keyapis::telemetry_control::v1::Device_MetricPoint >(GetArenaForAllocation()); } return _impl_.type_.metric_point_; } inline ::keyapis::telemetry_control::v1::Device_MetricPoint* Resource::mutable_metric_point() { ::keyapis::telemetry_control::v1::Device_MetricPoint* _msg = _internal_mutable_metric_point(); // @@protoc_insertion_point(field_mutable:keyapis.telemetry_control.v1.Resource.metric_point) return _msg; } // .keyapis.telemetry_control.v1.Indicator indicator = 4; inline bool Resource::has_indicator() const { return type_case() == kIndicator; } inline bool Resource::_internal_has_indicator() const { return type_case() == kIndicator; } inline void Resource::set_has_indicator() { _impl_._oneof_case_[0] = kIndicator; } inline ::keyapis::telemetry_control::v1::Indicator* Resource::release_indicator() { // @@protoc_insertion_point(field_release:keyapis.telemetry_control.v1.Resource.indicator) if (type_case() == kIndicator) { clear_has_type(); ::keyapis::telemetry_control::v1::Indicator* temp = _impl_.type_.indicator_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.type_.indicator_ = nullptr; return temp; } else { return nullptr; } } inline const ::keyapis::telemetry_control::v1::Indicator& Resource::_internal_indicator() const { return type_case() == kIndicator ? *_impl_.type_.indicator_ : reinterpret_cast<::keyapis::telemetry_control::v1::Indicator&>(::keyapis::telemetry_control::v1::_Indicator_default_instance_); } inline const ::keyapis::telemetry_control::v1::Indicator& Resource::indicator() const { // @@protoc_insertion_point(field_get:keyapis.telemetry_control.v1.Resource.indicator) return _internal_indicator(); } inline ::keyapis::telemetry_control::v1::Indicator* Resource::unsafe_arena_release_indicator() { // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.telemetry_control.v1.Resource.indicator) if (type_case() == kIndicator) { clear_has_type(); ::keyapis::telemetry_control::v1::Indicator* temp = _impl_.type_.indicator_; _impl_.type_.indicator_ = nullptr; return temp; } else { return nullptr; } } inline void Resource::unsafe_arena_set_allocated_indicator(::keyapis::telemetry_control::v1::Indicator* indicator) { clear_type(); if (indicator) { set_has_indicator(); _impl_.type_.indicator_ = indicator; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.telemetry_control.v1.Resource.indicator) } inline ::keyapis::telemetry_control::v1::Indicator* Resource::_internal_mutable_indicator() { if (type_case() != kIndicator) { clear_type(); set_has_indicator(); _impl_.type_.indicator_ = CreateMaybeMessage< ::keyapis::telemetry_control::v1::Indicator >(GetArenaForAllocation()); } return _impl_.type_.indicator_; } inline ::keyapis::telemetry_control::v1::Indicator* Resource::mutable_indicator() { ::keyapis::telemetry_control::v1::Indicator* _msg = _internal_mutable_indicator(); // @@protoc_insertion_point(field_mutable:keyapis.telemetry_control.v1.Resource.indicator) return _msg; } // .keyapis.telemetry_control.v1.DeviceIndicatorMetricPoint indicator_metric_point = 5; inline bool Resource::has_indicator_metric_point() const { return type_case() == kIndicatorMetricPoint; } inline bool Resource::_internal_has_indicator_metric_point() const { return type_case() == kIndicatorMetricPoint; } inline void Resource::set_has_indicator_metric_point() { _impl_._oneof_case_[0] = kIndicatorMetricPoint; } inline ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* Resource::release_indicator_metric_point() { // @@protoc_insertion_point(field_release:keyapis.telemetry_control.v1.Resource.indicator_metric_point) if (type_case() == kIndicatorMetricPoint) { clear_has_type(); ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* temp = _impl_.type_.indicator_metric_point_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.type_.indicator_metric_point_ = nullptr; return temp; } else { return nullptr; } } inline const ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint& Resource::_internal_indicator_metric_point() const { return type_case() == kIndicatorMetricPoint ? *_impl_.type_.indicator_metric_point_ : reinterpret_cast<::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint&>(::keyapis::telemetry_control::v1::_DeviceIndicatorMetricPoint_default_instance_); } inline const ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint& Resource::indicator_metric_point() const { // @@protoc_insertion_point(field_get:keyapis.telemetry_control.v1.Resource.indicator_metric_point) return _internal_indicator_metric_point(); } inline ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* Resource::unsafe_arena_release_indicator_metric_point() { // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.telemetry_control.v1.Resource.indicator_metric_point) if (type_case() == kIndicatorMetricPoint) { clear_has_type(); ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* temp = _impl_.type_.indicator_metric_point_; _impl_.type_.indicator_metric_point_ = nullptr; return temp; } else { return nullptr; } } inline void Resource::unsafe_arena_set_allocated_indicator_metric_point(::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* indicator_metric_point) { clear_type(); if (indicator_metric_point) { set_has_indicator_metric_point(); _impl_.type_.indicator_metric_point_ = indicator_metric_point; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.telemetry_control.v1.Resource.indicator_metric_point) } inline ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* Resource::_internal_mutable_indicator_metric_point() { if (type_case() != kIndicatorMetricPoint) { clear_type(); set_has_indicator_metric_point(); _impl_.type_.indicator_metric_point_ = CreateMaybeMessage< ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint >(GetArenaForAllocation()); } return _impl_.type_.indicator_metric_point_; } inline ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* Resource::mutable_indicator_metric_point() { ::keyapis::telemetry_control::v1::DeviceIndicatorMetricPoint* _msg = _internal_mutable_indicator_metric_point(); // @@protoc_insertion_point(field_mutable:keyapis.telemetry_control.v1.Resource.indicator_metric_point) return _msg; } inline bool Resource::has_type() const { return type_case() != TYPE_NOT_SET; } inline void Resource::clear_has_type() { _impl_._oneof_case_[0] = TYPE_NOT_SET; } inline Resource::TypeCase Resource::type_case() const { return Resource::TypeCase(_impl_._oneof_case_[0]); } // ------------------------------------------------------------------- // PostResourceFullDuplexRequest_ResourceAsyncStatus_Success // ------------------------------------------------------------------- // PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError // string message = 1 [(.google.api.field_behavior) = REQUIRED]; inline void PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError::clear_message() { _impl_.message_.ClearToEmpty(); } inline const std::string& PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError::message() const { // @@protoc_insertion_point(field_get:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.Error.UnknownError.message) return _internal_message(); } template inline PROTOBUF_ALWAYS_INLINE void PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError::set_message(Arg_&& arg, Args_... args) { ; _impl_.message_.Set(static_cast(arg), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.Error.UnknownError.message) } inline std::string* PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError::mutable_message() { std::string* _s = _internal_mutable_message(); // @@protoc_insertion_point(field_mutable:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.Error.UnknownError.message) return _s; } inline const std::string& PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError::_internal_message() const { return _impl_.message_.Get(); } inline void PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError::_internal_set_message(const std::string& value) { ; _impl_.message_.Set(value, GetArenaForAllocation()); } inline std::string* PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError::_internal_mutable_message() { ; return _impl_.message_.Mutable( GetArenaForAllocation()); } inline std::string* PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError::release_message() { // @@protoc_insertion_point(field_release:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.Error.UnknownError.message) return _impl_.message_.Release(); } inline void PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError::set_allocated_message(std::string* value) { _impl_.message_.SetAllocated(value, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.message_.IsDefault()) { _impl_.message_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.Error.UnknownError.message) } // ------------------------------------------------------------------- // PostResourceFullDuplexRequest_ResourceAsyncStatus_Error // .keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.Error.UnknownError unknown = 1; inline bool PostResourceFullDuplexRequest_ResourceAsyncStatus_Error::has_unknown() const { return reason_case() == kUnknown; } inline bool PostResourceFullDuplexRequest_ResourceAsyncStatus_Error::_internal_has_unknown() const { return reason_case() == kUnknown; } inline void PostResourceFullDuplexRequest_ResourceAsyncStatus_Error::set_has_unknown() { _impl_._oneof_case_[0] = kUnknown; } inline void PostResourceFullDuplexRequest_ResourceAsyncStatus_Error::clear_unknown() { if (reason_case() == kUnknown) { if (GetArenaForAllocation() == nullptr) { delete _impl_.reason_.unknown_; } clear_has_reason(); } } inline ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError* PostResourceFullDuplexRequest_ResourceAsyncStatus_Error::release_unknown() { // @@protoc_insertion_point(field_release:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.Error.unknown) if (reason_case() == kUnknown) { clear_has_reason(); ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError* temp = _impl_.reason_.unknown_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.reason_.unknown_ = nullptr; return temp; } else { return nullptr; } } inline const ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError& PostResourceFullDuplexRequest_ResourceAsyncStatus_Error::_internal_unknown() const { return reason_case() == kUnknown ? *_impl_.reason_.unknown_ : reinterpret_cast<::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError&>(::keyapis::telemetry_control::v1::_PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError_default_instance_); } inline const ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError& PostResourceFullDuplexRequest_ResourceAsyncStatus_Error::unknown() const { // @@protoc_insertion_point(field_get:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.Error.unknown) return _internal_unknown(); } inline ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError* PostResourceFullDuplexRequest_ResourceAsyncStatus_Error::unsafe_arena_release_unknown() { // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.Error.unknown) if (reason_case() == kUnknown) { clear_has_reason(); ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError* temp = _impl_.reason_.unknown_; _impl_.reason_.unknown_ = nullptr; return temp; } else { return nullptr; } } inline void PostResourceFullDuplexRequest_ResourceAsyncStatus_Error::unsafe_arena_set_allocated_unknown(::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError* unknown) { clear_reason(); if (unknown) { set_has_unknown(); _impl_.reason_.unknown_ = unknown; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.Error.unknown) } inline ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError* PostResourceFullDuplexRequest_ResourceAsyncStatus_Error::_internal_mutable_unknown() { if (reason_case() != kUnknown) { clear_reason(); set_has_unknown(); _impl_.reason_.unknown_ = CreateMaybeMessage< ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError >(GetArenaForAllocation()); } return _impl_.reason_.unknown_; } inline ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError* PostResourceFullDuplexRequest_ResourceAsyncStatus_Error::mutable_unknown() { ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_UnknownError* _msg = _internal_mutable_unknown(); // @@protoc_insertion_point(field_mutable:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.Error.unknown) return _msg; } inline bool PostResourceFullDuplexRequest_ResourceAsyncStatus_Error::has_reason() const { return reason_case() != REASON_NOT_SET; } inline void PostResourceFullDuplexRequest_ResourceAsyncStatus_Error::clear_has_reason() { _impl_._oneof_case_[0] = REASON_NOT_SET; } inline PostResourceFullDuplexRequest_ResourceAsyncStatus_Error::ReasonCase PostResourceFullDuplexRequest_ResourceAsyncStatus_Error::reason_case() const { return PostResourceFullDuplexRequest_ResourceAsyncStatus_Error::ReasonCase(_impl_._oneof_case_[0]); } // ------------------------------------------------------------------- // PostResourceFullDuplexRequest_ResourceAsyncStatus // .keyapis.telemetry_control.v1.ResourceId resource_id = 1 [(.google.api.field_behavior) = REQUIRED]; inline bool PostResourceFullDuplexRequest_ResourceAsyncStatus::has_resource_id() const { bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; PROTOBUF_ASSUME(!value || _impl_.resource_id_ != nullptr); return value; } inline void PostResourceFullDuplexRequest_ResourceAsyncStatus::clear_resource_id() { if (_impl_.resource_id_ != nullptr) _impl_.resource_id_->Clear(); _impl_._has_bits_[0] &= ~0x00000001u; } inline const ::keyapis::telemetry_control::v1::ResourceId& PostResourceFullDuplexRequest_ResourceAsyncStatus::_internal_resource_id() const { const ::keyapis::telemetry_control::v1::ResourceId* p = _impl_.resource_id_; return p != nullptr ? *p : reinterpret_cast( ::keyapis::telemetry_control::v1::_ResourceId_default_instance_); } inline const ::keyapis::telemetry_control::v1::ResourceId& PostResourceFullDuplexRequest_ResourceAsyncStatus::resource_id() const { // @@protoc_insertion_point(field_get:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.resource_id) return _internal_resource_id(); } inline void PostResourceFullDuplexRequest_ResourceAsyncStatus::unsafe_arena_set_allocated_resource_id( ::keyapis::telemetry_control::v1::ResourceId* resource_id) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.resource_id_); } _impl_.resource_id_ = resource_id; if (resource_id) { _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.resource_id) } inline ::keyapis::telemetry_control::v1::ResourceId* PostResourceFullDuplexRequest_ResourceAsyncStatus::release_resource_id() { _impl_._has_bits_[0] &= ~0x00000001u; ::keyapis::telemetry_control::v1::ResourceId* temp = _impl_.resource_id_; _impl_.resource_id_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::keyapis::telemetry_control::v1::ResourceId* PostResourceFullDuplexRequest_ResourceAsyncStatus::unsafe_arena_release_resource_id() { // @@protoc_insertion_point(field_release:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.resource_id) _impl_._has_bits_[0] &= ~0x00000001u; ::keyapis::telemetry_control::v1::ResourceId* temp = _impl_.resource_id_; _impl_.resource_id_ = nullptr; return temp; } inline ::keyapis::telemetry_control::v1::ResourceId* PostResourceFullDuplexRequest_ResourceAsyncStatus::_internal_mutable_resource_id() { _impl_._has_bits_[0] |= 0x00000001u; if (_impl_.resource_id_ == nullptr) { auto* p = CreateMaybeMessage<::keyapis::telemetry_control::v1::ResourceId>(GetArenaForAllocation()); _impl_.resource_id_ = p; } return _impl_.resource_id_; } inline ::keyapis::telemetry_control::v1::ResourceId* PostResourceFullDuplexRequest_ResourceAsyncStatus::mutable_resource_id() { ::keyapis::telemetry_control::v1::ResourceId* _msg = _internal_mutable_resource_id(); // @@protoc_insertion_point(field_mutable:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.resource_id) return _msg; } inline void PostResourceFullDuplexRequest_ResourceAsyncStatus::set_allocated_resource_id(::keyapis::telemetry_control::v1::ResourceId* resource_id) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.resource_id_; } if (resource_id) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(resource_id); if (message_arena != submessage_arena) { resource_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, resource_id, submessage_arena); } _impl_._has_bits_[0] |= 0x00000001u; } else { _impl_._has_bits_[0] &= ~0x00000001u; } _impl_.resource_id_ = resource_id; // @@protoc_insertion_point(field_set_allocated:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.resource_id) } // .keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.Success data = 2; inline bool PostResourceFullDuplexRequest_ResourceAsyncStatus::has_data() const { return type_case() == kData; } inline bool PostResourceFullDuplexRequest_ResourceAsyncStatus::_internal_has_data() const { return type_case() == kData; } inline void PostResourceFullDuplexRequest_ResourceAsyncStatus::set_has_data() { _impl_._oneof_case_[0] = kData; } inline void PostResourceFullDuplexRequest_ResourceAsyncStatus::clear_data() { if (type_case() == kData) { if (GetArenaForAllocation() == nullptr) { delete _impl_.type_.data_; } clear_has_type(); } } inline ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Success* PostResourceFullDuplexRequest_ResourceAsyncStatus::release_data() { // @@protoc_insertion_point(field_release:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.data) if (type_case() == kData) { clear_has_type(); ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Success* temp = _impl_.type_.data_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.type_.data_ = nullptr; return temp; } else { return nullptr; } } inline const ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Success& PostResourceFullDuplexRequest_ResourceAsyncStatus::_internal_data() const { return type_case() == kData ? *_impl_.type_.data_ : reinterpret_cast<::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Success&>(::keyapis::telemetry_control::v1::_PostResourceFullDuplexRequest_ResourceAsyncStatus_Success_default_instance_); } inline const ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Success& PostResourceFullDuplexRequest_ResourceAsyncStatus::data() const { // @@protoc_insertion_point(field_get:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.data) return _internal_data(); } inline ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Success* PostResourceFullDuplexRequest_ResourceAsyncStatus::unsafe_arena_release_data() { // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.data) if (type_case() == kData) { clear_has_type(); ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Success* temp = _impl_.type_.data_; _impl_.type_.data_ = nullptr; return temp; } else { return nullptr; } } inline void PostResourceFullDuplexRequest_ResourceAsyncStatus::unsafe_arena_set_allocated_data(::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Success* data) { clear_type(); if (data) { set_has_data(); _impl_.type_.data_ = data; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.data) } inline ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Success* PostResourceFullDuplexRequest_ResourceAsyncStatus::_internal_mutable_data() { if (type_case() != kData) { clear_type(); set_has_data(); _impl_.type_.data_ = CreateMaybeMessage< ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Success >(GetArenaForAllocation()); } return _impl_.type_.data_; } inline ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Success* PostResourceFullDuplexRequest_ResourceAsyncStatus::mutable_data() { ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Success* _msg = _internal_mutable_data(); // @@protoc_insertion_point(field_mutable:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.data) return _msg; } // .keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.Error error = 3; inline bool PostResourceFullDuplexRequest_ResourceAsyncStatus::has_error() const { return type_case() == kError; } inline bool PostResourceFullDuplexRequest_ResourceAsyncStatus::_internal_has_error() const { return type_case() == kError; } inline void PostResourceFullDuplexRequest_ResourceAsyncStatus::set_has_error() { _impl_._oneof_case_[0] = kError; } inline void PostResourceFullDuplexRequest_ResourceAsyncStatus::clear_error() { if (type_case() == kError) { if (GetArenaForAllocation() == nullptr) { delete _impl_.type_.error_; } clear_has_type(); } } inline ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error* PostResourceFullDuplexRequest_ResourceAsyncStatus::release_error() { // @@protoc_insertion_point(field_release:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.error) if (type_case() == kError) { clear_has_type(); ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error* temp = _impl_.type_.error_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.type_.error_ = nullptr; return temp; } else { return nullptr; } } inline const ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error& PostResourceFullDuplexRequest_ResourceAsyncStatus::_internal_error() const { return type_case() == kError ? *_impl_.type_.error_ : reinterpret_cast<::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error&>(::keyapis::telemetry_control::v1::_PostResourceFullDuplexRequest_ResourceAsyncStatus_Error_default_instance_); } inline const ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error& PostResourceFullDuplexRequest_ResourceAsyncStatus::error() const { // @@protoc_insertion_point(field_get:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.error) return _internal_error(); } inline ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error* PostResourceFullDuplexRequest_ResourceAsyncStatus::unsafe_arena_release_error() { // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.error) if (type_case() == kError) { clear_has_type(); ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error* temp = _impl_.type_.error_; _impl_.type_.error_ = nullptr; return temp; } else { return nullptr; } } inline void PostResourceFullDuplexRequest_ResourceAsyncStatus::unsafe_arena_set_allocated_error(::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error* error) { clear_type(); if (error) { set_has_error(); _impl_.type_.error_ = error; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.error) } inline ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error* PostResourceFullDuplexRequest_ResourceAsyncStatus::_internal_mutable_error() { if (type_case() != kError) { clear_type(); set_has_error(); _impl_.type_.error_ = CreateMaybeMessage< ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error >(GetArenaForAllocation()); } return _impl_.type_.error_; } inline ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error* PostResourceFullDuplexRequest_ResourceAsyncStatus::mutable_error() { ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus_Error* _msg = _internal_mutable_error(); // @@protoc_insertion_point(field_mutable:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus.error) return _msg; } inline bool PostResourceFullDuplexRequest_ResourceAsyncStatus::has_type() const { return type_case() != TYPE_NOT_SET; } inline void PostResourceFullDuplexRequest_ResourceAsyncStatus::clear_has_type() { _impl_._oneof_case_[0] = TYPE_NOT_SET; } inline PostResourceFullDuplexRequest_ResourceAsyncStatus::TypeCase PostResourceFullDuplexRequest_ResourceAsyncStatus::type_case() const { return PostResourceFullDuplexRequest_ResourceAsyncStatus::TypeCase(_impl_._oneof_case_[0]); } // ------------------------------------------------------------------- // PostResourceFullDuplexRequest // string request_id = 1; inline void PostResourceFullDuplexRequest::clear_request_id() { _impl_.request_id_.ClearToEmpty(); } inline const std::string& PostResourceFullDuplexRequest::request_id() const { // @@protoc_insertion_point(field_get:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.request_id) return _internal_request_id(); } template inline PROTOBUF_ALWAYS_INLINE void PostResourceFullDuplexRequest::set_request_id(Arg_&& arg, Args_... args) { ; _impl_.request_id_.Set(static_cast(arg), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.request_id) } inline std::string* PostResourceFullDuplexRequest::mutable_request_id() { std::string* _s = _internal_mutable_request_id(); // @@protoc_insertion_point(field_mutable:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.request_id) return _s; } inline const std::string& PostResourceFullDuplexRequest::_internal_request_id() const { return _impl_.request_id_.Get(); } inline void PostResourceFullDuplexRequest::_internal_set_request_id(const std::string& value) { ; _impl_.request_id_.Set(value, GetArenaForAllocation()); } inline std::string* PostResourceFullDuplexRequest::_internal_mutable_request_id() { ; return _impl_.request_id_.Mutable( GetArenaForAllocation()); } inline std::string* PostResourceFullDuplexRequest::release_request_id() { // @@protoc_insertion_point(field_release:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.request_id) return _impl_.request_id_.Release(); } inline void PostResourceFullDuplexRequest::set_allocated_request_id(std::string* value) { _impl_.request_id_.SetAllocated(value, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.request_id_.IsDefault()) { _impl_.request_id_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.request_id) } // .keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.ResourceAsyncStatus resource_async_status = 2; inline bool PostResourceFullDuplexRequest::has_resource_async_status() const { return task_case() == kResourceAsyncStatus; } inline bool PostResourceFullDuplexRequest::_internal_has_resource_async_status() const { return task_case() == kResourceAsyncStatus; } inline void PostResourceFullDuplexRequest::set_has_resource_async_status() { _impl_._oneof_case_[0] = kResourceAsyncStatus; } inline void PostResourceFullDuplexRequest::clear_resource_async_status() { if (task_case() == kResourceAsyncStatus) { if (GetArenaForAllocation() == nullptr) { delete _impl_.task_.resource_async_status_; } clear_has_task(); } } inline ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus* PostResourceFullDuplexRequest::release_resource_async_status() { // @@protoc_insertion_point(field_release:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.resource_async_status) if (task_case() == kResourceAsyncStatus) { clear_has_task(); ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus* temp = _impl_.task_.resource_async_status_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.task_.resource_async_status_ = nullptr; return temp; } else { return nullptr; } } inline const ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus& PostResourceFullDuplexRequest::_internal_resource_async_status() const { return task_case() == kResourceAsyncStatus ? *_impl_.task_.resource_async_status_ : reinterpret_cast<::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus&>(::keyapis::telemetry_control::v1::_PostResourceFullDuplexRequest_ResourceAsyncStatus_default_instance_); } inline const ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus& PostResourceFullDuplexRequest::resource_async_status() const { // @@protoc_insertion_point(field_get:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.resource_async_status) return _internal_resource_async_status(); } inline ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus* PostResourceFullDuplexRequest::unsafe_arena_release_resource_async_status() { // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.resource_async_status) if (task_case() == kResourceAsyncStatus) { clear_has_task(); ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus* temp = _impl_.task_.resource_async_status_; _impl_.task_.resource_async_status_ = nullptr; return temp; } else { return nullptr; } } inline void PostResourceFullDuplexRequest::unsafe_arena_set_allocated_resource_async_status(::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus* resource_async_status) { clear_task(); if (resource_async_status) { set_has_resource_async_status(); _impl_.task_.resource_async_status_ = resource_async_status; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.resource_async_status) } inline ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus* PostResourceFullDuplexRequest::_internal_mutable_resource_async_status() { if (task_case() != kResourceAsyncStatus) { clear_task(); set_has_resource_async_status(); _impl_.task_.resource_async_status_ = CreateMaybeMessage< ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus >(GetArenaForAllocation()); } return _impl_.task_.resource_async_status_; } inline ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus* PostResourceFullDuplexRequest::mutable_resource_async_status() { ::keyapis::telemetry_control::v1::PostResourceFullDuplexRequest_ResourceAsyncStatus* _msg = _internal_mutable_resource_async_status(); // @@protoc_insertion_point(field_mutable:keyapis.telemetry_control.v1.PostResourceFullDuplexRequest.resource_async_status) return _msg; } inline bool PostResourceFullDuplexRequest::has_task() const { return task_case() != TASK_NOT_SET; } inline void PostResourceFullDuplexRequest::clear_has_task() { _impl_._oneof_case_[0] = TASK_NOT_SET; } inline PostResourceFullDuplexRequest::TaskCase PostResourceFullDuplexRequest::task_case() const { return PostResourceFullDuplexRequest::TaskCase(_impl_._oneof_case_[0]); } #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ // @@protoc_insertion_point(namespace_scope) } // namespace v1 } // namespace telemetry_control } // namespace keyapis // @@protoc_insertion_point(global_scope) #include "google/protobuf/port_undef.inc" #endif // GOOGLE_PROTOBUF_INCLUDED_keyapis_2ftelemetry_5fcontrol_2fv1_2fkeyapis_5ftelemetry_5fcontrol_5fstream_5fv1_2eproto_2epb_2eh