diff --git a/native/cpp/CommonCpp/grpc/_generated/backup.pb.h b/native/cpp/CommonCpp/grpc/_generated/backup.pb.h --- a/native/cpp/CommonCpp/grpc/_generated/backup.pb.h +++ b/native/cpp/CommonCpp/grpc/_generated/backup.pb.h @@ -1373,9 +1373,15 @@ static const PullBackupResponse& default_instance() { return *internal_default_instance(); } + enum IdCase { + kBackupID = 1, + kLogID = 2, + ID_NOT_SET = 0, + }; + enum DataCase { - kCompactionChunk = 1, - kLogChunk = 2, + kCompactionChunk = 3, + kLogChunk = 4, DATA_NOT_SET = 0, }; @@ -1454,20 +1460,73 @@ // accessors ------------------------------------------------------- enum : int { - kChunkCounterFieldNumber = 3, - kCompactionChunkFieldNumber = 1, - kLogChunkFieldNumber = 2, + kAttachmentHoldersFieldNumber = 5, + kBackupIDFieldNumber = 1, + kLogIDFieldNumber = 2, + kCompactionChunkFieldNumber = 3, + kLogChunkFieldNumber = 4, }; - // int32 chunkCounter = 3; - void clear_chunkcounter(); - ::PROTOBUF_NAMESPACE_ID::int32 chunkcounter() const; - void set_chunkcounter(::PROTOBUF_NAMESPACE_ID::int32 value); + // string attachmentHolders = 5; + bool has_attachmentholders() const; private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_chunkcounter() const; - void _internal_set_chunkcounter(::PROTOBUF_NAMESPACE_ID::int32 value); + bool _internal_has_attachmentholders() const; + public: + void clear_attachmentholders(); + const std::string& attachmentholders() const; + void set_attachmentholders(const std::string& value); + void set_attachmentholders(std::string&& value); + void set_attachmentholders(const char* value); + void set_attachmentholders(const char* value, size_t size); + std::string* mutable_attachmentholders(); + std::string* release_attachmentholders(); + void set_allocated_attachmentholders(std::string* attachmentholders); + private: + const std::string& _internal_attachmentholders() const; + void _internal_set_attachmentholders(const std::string& value); + std::string* _internal_mutable_attachmentholders(); public: - // bytes compactionChunk = 1; + // string backupID = 1; + bool has_backupid() const; + private: + bool _internal_has_backupid() const; + public: + void clear_backupid(); + const std::string& backupid() const; + void set_backupid(const std::string& value); + void set_backupid(std::string&& value); + void set_backupid(const char* value); + void set_backupid(const char* value, size_t size); + std::string* mutable_backupid(); + std::string* release_backupid(); + void set_allocated_backupid(std::string* backupid); + private: + const std::string& _internal_backupid() const; + void _internal_set_backupid(const std::string& value); + std::string* _internal_mutable_backupid(); + public: + + // string logID = 2; + bool has_logid() const; + private: + bool _internal_has_logid() const; + public: + void clear_logid(); + const std::string& logid() const; + void set_logid(const std::string& value); + void set_logid(std::string&& value); + void set_logid(const char* value); + void set_logid(const char* value, size_t size); + std::string* mutable_logid(); + std::string* release_logid(); + void set_allocated_logid(std::string* logid); + private: + const std::string& _internal_logid() const; + void _internal_set_logid(const std::string& value); + std::string* _internal_mutable_logid(); + public: + + // bytes compactionChunk = 3; bool has_compactionchunk() const; private: bool _internal_has_compactionchunk() const; @@ -1487,7 +1546,7 @@ std::string* _internal_mutable_compactionchunk(); public: - // bytes logChunk = 2; + // bytes logChunk = 4; bool has_logchunk() const; private: bool _internal_has_logchunk() const; @@ -1507,29 +1566,43 @@ std::string* _internal_mutable_logchunk(); public: + void clear_id(); + IdCase id_case() const; void clear_data(); DataCase data_case() const; // @@protoc_insertion_point(class_scope:backup.PullBackupResponse) private: class _Internal; + void set_has_backupid(); + void set_has_logid(); void set_has_compactionchunk(); void set_has_logchunk(); + inline bool has_id() const; + inline void clear_has_id(); + inline bool has_data() const; inline void clear_has_data(); template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::int32 chunkcounter_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachmentholders_; + union IdUnion { + constexpr IdUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr backupid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr logid_; + } id_; union DataUnion { constexpr DataUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr compactionchunk_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr logchunk_; } data_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[2]; friend struct ::TableStruct_backup_2eproto; }; @@ -3144,7 +3217,227 @@ // PullBackupResponse -// bytes compactionChunk = 1; +// string backupID = 1; +inline bool PullBackupResponse::_internal_has_backupid() const { + return id_case() == kBackupID; +} +inline bool PullBackupResponse::has_backupid() const { + return _internal_has_backupid(); +} +inline void PullBackupResponse::set_has_backupid() { + _oneof_case_[0] = kBackupID; +} +inline void PullBackupResponse::clear_backupid() { + if (_internal_has_backupid()) { + id_.backupid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_id(); + } +} +inline const std::string& PullBackupResponse::backupid() const { + // @@protoc_insertion_point(field_get:backup.PullBackupResponse.backupID) + return _internal_backupid(); +} +inline void PullBackupResponse::set_backupid(const std::string& value) { + _internal_set_backupid(value); + // @@protoc_insertion_point(field_set:backup.PullBackupResponse.backupID) +} +inline std::string* PullBackupResponse::mutable_backupid() { + // @@protoc_insertion_point(field_mutable:backup.PullBackupResponse.backupID) + return _internal_mutable_backupid(); +} +inline const std::string& PullBackupResponse::_internal_backupid() const { + if (_internal_has_backupid()) { + return id_.backupid_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void PullBackupResponse::_internal_set_backupid(const std::string& value) { + if (!_internal_has_backupid()) { + clear_id(); + set_has_backupid(); + id_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + id_.backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline void PullBackupResponse::set_backupid(std::string&& value) { + // @@protoc_insertion_point(field_set:backup.PullBackupResponse.backupID) + if (!_internal_has_backupid()) { + clear_id(); + set_has_backupid(); + id_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + id_.backupid_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupResponse.backupID) +} +inline void PullBackupResponse::set_backupid(const char* value) { + GOOGLE_DCHECK(value != nullptr); + if (!_internal_has_backupid()) { + clear_id(); + set_has_backupid(); + id_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + id_.backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, + ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:backup.PullBackupResponse.backupID) +} +inline void PullBackupResponse::set_backupid(const char* value, + size_t size) { + if (!_internal_has_backupid()) { + clear_id(); + set_has_backupid(); + id_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + id_.backupid_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + reinterpret_cast(value), size), + GetArena()); + // @@protoc_insertion_point(field_set_pointer:backup.PullBackupResponse.backupID) +} +inline std::string* PullBackupResponse::_internal_mutable_backupid() { + if (!_internal_has_backupid()) { + clear_id(); + set_has_backupid(); + id_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return id_.backupid_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* PullBackupResponse::release_backupid() { + // @@protoc_insertion_point(field_release:backup.PullBackupResponse.backupID) + if (_internal_has_backupid()) { + clear_has_id(); + return id_.backupid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void PullBackupResponse::set_allocated_backupid(std::string* backupid) { + if (has_id()) { + clear_id(); + } + if (backupid != nullptr) { + set_has_backupid(); + id_.backupid_.UnsafeSetDefault(backupid); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(backupid); + } + } + // @@protoc_insertion_point(field_set_allocated:backup.PullBackupResponse.backupID) +} + +// string logID = 2; +inline bool PullBackupResponse::_internal_has_logid() const { + return id_case() == kLogID; +} +inline bool PullBackupResponse::has_logid() const { + return _internal_has_logid(); +} +inline void PullBackupResponse::set_has_logid() { + _oneof_case_[0] = kLogID; +} +inline void PullBackupResponse::clear_logid() { + if (_internal_has_logid()) { + id_.logid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_id(); + } +} +inline const std::string& PullBackupResponse::logid() const { + // @@protoc_insertion_point(field_get:backup.PullBackupResponse.logID) + return _internal_logid(); +} +inline void PullBackupResponse::set_logid(const std::string& value) { + _internal_set_logid(value); + // @@protoc_insertion_point(field_set:backup.PullBackupResponse.logID) +} +inline std::string* PullBackupResponse::mutable_logid() { + // @@protoc_insertion_point(field_mutable:backup.PullBackupResponse.logID) + return _internal_mutable_logid(); +} +inline const std::string& PullBackupResponse::_internal_logid() const { + if (_internal_has_logid()) { + return id_.logid_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void PullBackupResponse::_internal_set_logid(const std::string& value) { + if (!_internal_has_logid()) { + clear_id(); + set_has_logid(); + id_.logid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + id_.logid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline void PullBackupResponse::set_logid(std::string&& value) { + // @@protoc_insertion_point(field_set:backup.PullBackupResponse.logID) + if (!_internal_has_logid()) { + clear_id(); + set_has_logid(); + id_.logid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + id_.logid_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupResponse.logID) +} +inline void PullBackupResponse::set_logid(const char* value) { + GOOGLE_DCHECK(value != nullptr); + if (!_internal_has_logid()) { + clear_id(); + set_has_logid(); + id_.logid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + id_.logid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, + ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:backup.PullBackupResponse.logID) +} +inline void PullBackupResponse::set_logid(const char* value, + size_t size) { + if (!_internal_has_logid()) { + clear_id(); + set_has_logid(); + id_.logid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + id_.logid_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + reinterpret_cast(value), size), + GetArena()); + // @@protoc_insertion_point(field_set_pointer:backup.PullBackupResponse.logID) +} +inline std::string* PullBackupResponse::_internal_mutable_logid() { + if (!_internal_has_logid()) { + clear_id(); + set_has_logid(); + id_.logid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return id_.logid_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* PullBackupResponse::release_logid() { + // @@protoc_insertion_point(field_release:backup.PullBackupResponse.logID) + if (_internal_has_logid()) { + clear_has_id(); + return id_.logid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void PullBackupResponse::set_allocated_logid(std::string* logid) { + if (has_id()) { + clear_id(); + } + if (logid != nullptr) { + set_has_logid(); + id_.logid_.UnsafeSetDefault(logid); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(logid); + } + } + // @@protoc_insertion_point(field_set_allocated:backup.PullBackupResponse.logID) +} + +// bytes compactionChunk = 3; inline bool PullBackupResponse::_internal_has_compactionchunk() const { return data_case() == kCompactionChunk; } @@ -3152,7 +3445,7 @@ return _internal_has_compactionchunk(); } inline void PullBackupResponse::set_has_compactionchunk() { - _oneof_case_[0] = kCompactionChunk; + _oneof_case_[1] = kCompactionChunk; } inline void PullBackupResponse::clear_compactionchunk() { if (_internal_has_compactionchunk()) { @@ -3254,7 +3547,7 @@ // @@protoc_insertion_point(field_set_allocated:backup.PullBackupResponse.compactionChunk) } -// bytes logChunk = 2; +// bytes logChunk = 4; inline bool PullBackupResponse::_internal_has_logchunk() const { return data_case() == kLogChunk; } @@ -3262,7 +3555,7 @@ return _internal_has_logchunk(); } inline void PullBackupResponse::set_has_logchunk() { - _oneof_case_[0] = kLogChunk; + _oneof_case_[1] = kLogChunk; } inline void PullBackupResponse::clear_logchunk() { if (_internal_has_logchunk()) { @@ -3364,34 +3657,96 @@ // @@protoc_insertion_point(field_set_allocated:backup.PullBackupResponse.logChunk) } -// int32 chunkCounter = 3; -inline void PullBackupResponse::clear_chunkcounter() { - chunkcounter_ = 0; +// string attachmentHolders = 5; +inline bool PullBackupResponse::_internal_has_attachmentholders() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; } -inline ::PROTOBUF_NAMESPACE_ID::int32 PullBackupResponse::_internal_chunkcounter() const { - return chunkcounter_; +inline bool PullBackupResponse::has_attachmentholders() const { + return _internal_has_attachmentholders(); } -inline ::PROTOBUF_NAMESPACE_ID::int32 PullBackupResponse::chunkcounter() const { - // @@protoc_insertion_point(field_get:backup.PullBackupResponse.chunkCounter) - return _internal_chunkcounter(); +inline void PullBackupResponse::clear_attachmentholders() { + attachmentholders_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; } -inline void PullBackupResponse::_internal_set_chunkcounter(::PROTOBUF_NAMESPACE_ID::int32 value) { - - chunkcounter_ = value; +inline const std::string& PullBackupResponse::attachmentholders() const { + // @@protoc_insertion_point(field_get:backup.PullBackupResponse.attachmentHolders) + return _internal_attachmentholders(); } -inline void PullBackupResponse::set_chunkcounter(::PROTOBUF_NAMESPACE_ID::int32 value) { - _internal_set_chunkcounter(value); - // @@protoc_insertion_point(field_set:backup.PullBackupResponse.chunkCounter) +inline void PullBackupResponse::set_attachmentholders(const std::string& value) { + _internal_set_attachmentholders(value); + // @@protoc_insertion_point(field_set:backup.PullBackupResponse.attachmentHolders) +} +inline std::string* PullBackupResponse::mutable_attachmentholders() { + // @@protoc_insertion_point(field_mutable:backup.PullBackupResponse.attachmentHolders) + return _internal_mutable_attachmentholders(); +} +inline const std::string& PullBackupResponse::_internal_attachmentholders() const { + return attachmentholders_.Get(); +} +inline void PullBackupResponse::_internal_set_attachmentholders(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + attachmentholders_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline void PullBackupResponse::set_attachmentholders(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + attachmentholders_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupResponse.attachmentHolders) +} +inline void PullBackupResponse::set_attachmentholders(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + attachmentholders_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:backup.PullBackupResponse.attachmentHolders) +} +inline void PullBackupResponse::set_attachmentholders(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + attachmentholders_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:backup.PullBackupResponse.attachmentHolders) +} +inline std::string* PullBackupResponse::_internal_mutable_attachmentholders() { + _has_bits_[0] |= 0x00000001u; + return attachmentholders_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* PullBackupResponse::release_attachmentholders() { + // @@protoc_insertion_point(field_release:backup.PullBackupResponse.attachmentHolders) + if (!_internal_has_attachmentholders()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return attachmentholders_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void PullBackupResponse::set_allocated_attachmentholders(std::string* attachmentholders) { + if (attachmentholders != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + attachmentholders_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), attachmentholders, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:backup.PullBackupResponse.attachmentHolders) } +inline bool PullBackupResponse::has_id() const { + return id_case() != ID_NOT_SET; +} +inline void PullBackupResponse::clear_has_id() { + _oneof_case_[0] = ID_NOT_SET; +} inline bool PullBackupResponse::has_data() const { return data_case() != DATA_NOT_SET; } inline void PullBackupResponse::clear_has_data() { - _oneof_case_[0] = DATA_NOT_SET; + _oneof_case_[1] = DATA_NOT_SET; +} +inline PullBackupResponse::IdCase PullBackupResponse::id_case() const { + return PullBackupResponse::IdCase(_oneof_case_[0]); } inline PullBackupResponse::DataCase PullBackupResponse::data_case() const { - return PullBackupResponse::DataCase(_oneof_case_[0]); + return PullBackupResponse::DataCase(_oneof_case_[1]); } // ------------------------------------------------------------------- diff --git a/native/cpp/CommonCpp/grpc/_generated/backup.pb.cc b/native/cpp/CommonCpp/grpc/_generated/backup.pb.cc --- a/native/cpp/CommonCpp/grpc/_generated/backup.pb.cc +++ b/native/cpp/CommonCpp/grpc/_generated/backup.pb.cc @@ -104,7 +104,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PullBackupRequestDefaultTypeInternal _PullBackupRequest_default_instance_; constexpr PullBackupResponse::PullBackupResponse( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : chunkcounter_(0) + : attachmentholders_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , _oneof_case_{}{} struct PullBackupResponseDefaultTypeInternal { constexpr PullBackupResponseDefaultTypeInternal() @@ -188,15 +188,23 @@ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::backup::PullBackupRequest, userid_), PROTOBUF_FIELD_OFFSET(::backup::PullBackupRequest, backupid_), - ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::backup::PullBackupResponse, _has_bits_), PROTOBUF_FIELD_OFFSET(::backup::PullBackupResponse, _internal_metadata_), ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::backup::PullBackupResponse, _oneof_case_[0]), ~0u, // no _weak_field_map_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::backup::PullBackupResponse, chunkcounter_), + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::backup::PullBackupResponse, attachmentholders_), + PROTOBUF_FIELD_OFFSET(::backup::PullBackupResponse, id_), PROTOBUF_FIELD_OFFSET(::backup::PullBackupResponse, data_), + ~0u, + ~0u, + ~0u, + ~0u, + 0, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::backup::AddAttachmentsRequest, _internal_metadata_), ~0u, // no _extensions_ @@ -215,8 +223,8 @@ { 33, -1, sizeof(::backup::RecoverBackupKeyRequest)}, { 39, -1, sizeof(::backup::RecoverBackupKeyResponse)}, { 45, -1, sizeof(::backup::PullBackupRequest)}, - { 52, -1, sizeof(::backup::PullBackupResponse)}, - { 61, -1, sizeof(::backup::AddAttachmentsRequest)}, + { 52, 64, sizeof(::backup::PullBackupResponse)}, + { 69, -1, sizeof(::backup::AddAttachmentsRequest)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { @@ -245,29 +253,31 @@ "coverBackupKeyRequest\022\016\n\006userID\030\001 \001(\t\",\n" "\030RecoverBackupKeyResponse\022\020\n\010backupID\030\004 " "\001(\t\"5\n\021PullBackupRequest\022\016\n\006userID\030\001 \001(\t" - "\022\020\n\010backupID\030\002 \001(\t\"a\n\022PullBackupResponse" - "\022\031\n\017compactionChunk\030\001 \001(\014H\000\022\022\n\010logChunk\030" - "\002 \001(\014H\000\022\024\n\014chunkCounter\030\003 \001(\005B\006\n\004data\"Y\n" - "\025AddAttachmentsRequest\022\016\n\006userID\030\001 \001(\t\022\020" - "\n\010backupID\030\002 \001(\t\022\r\n\005logID\030\003 \001(\t\022\017\n\007holde" - "rs\030\004 \001(\t2\232\003\n\rBackupService\022X\n\017CreateNewB" - "ackup\022\036.backup.CreateNewBackupRequest\032\037." - "backup.CreateNewBackupResponse\"\000(\0010\001\022>\n\007" - "SendLog\022\026.backup.SendLogRequest\032\027.backup" - ".SendLogResponse\"\000(\001\022[\n\020RecoverBackupKey" - "\022\037.backup.RecoverBackupKeyRequest\032 .back" - "up.RecoverBackupKeyResponse\"\000(\0010\001\022G\n\nPul" - "lBackup\022\031.backup.PullBackupRequest\032\032.bac" - "kup.PullBackupResponse\"\0000\001\022I\n\016AddAttachm" - "ents\022\035.backup.AddAttachmentsRequest\032\026.go" - "ogle.protobuf.Empty\"\000b\006proto3" + "\022\020\n\010backupID\030\002 \001(\t\"\254\001\n\022PullBackupRespons" + "e\022\022\n\010backupID\030\001 \001(\tH\000\022\017\n\005logID\030\002 \001(\tH\000\022\031" + "\n\017compactionChunk\030\003 \001(\014H\001\022\022\n\010logChunk\030\004 " + "\001(\014H\001\022\036\n\021attachmentHolders\030\005 \001(\tH\002\210\001\001B\004\n" + "\002idB\006\n\004dataB\024\n\022_attachmentHolders\"Y\n\025Add" + "AttachmentsRequest\022\016\n\006userID\030\001 \001(\t\022\020\n\010ba" + "ckupID\030\002 \001(\t\022\r\n\005logID\030\003 \001(\t\022\017\n\007holders\030\004" + " \001(\t2\232\003\n\rBackupService\022X\n\017CreateNewBacku" + "p\022\036.backup.CreateNewBackupRequest\032\037.back" + "up.CreateNewBackupResponse\"\000(\0010\001\022>\n\007Send" + "Log\022\026.backup.SendLogRequest\032\027.backup.Sen" + "dLogResponse\"\000(\001\022[\n\020RecoverBackupKey\022\037.b" + "ackup.RecoverBackupKeyRequest\032 .backup.R" + "ecoverBackupKeyResponse\"\000(\0010\001\022G\n\nPullBac" + "kup\022\031.backup.PullBackupRequest\032\032.backup." + "PullBackupResponse\"\0000\001\022I\n\016AddAttachments" + "\022\035.backup.AddAttachmentsRequest\032\026.google" + ".protobuf.Empty\"\000b\006proto3" ; static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_backup_2eproto_deps[1] = { &::descriptor_table_google_2fprotobuf_2fempty_2eproto, }; static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_backup_2eproto_once; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_backup_2eproto = { - false, false, 1149, descriptor_table_protodef_backup_2eproto, "backup.proto", + false, false, 1225, descriptor_table_protodef_backup_2eproto, "backup.proto", &descriptor_table_backup_2eproto_once, descriptor_table_backup_2eproto_deps, 1, 9, schemas, file_default_instances, TableStruct_backup_2eproto::offsets, file_level_metadata_backup_2eproto, file_level_enum_descriptors_backup_2eproto, file_level_service_descriptors_backup_2eproto, @@ -2033,6 +2043,10 @@ class PullBackupResponse::_Internal { public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_attachmentholders(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } }; PullBackupResponse::PullBackupResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena) @@ -2042,9 +2056,28 @@ // @@protoc_insertion_point(arena_constructor:backup.PullBackupResponse) } PullBackupResponse::PullBackupResponse(const PullBackupResponse& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - chunkcounter_ = from.chunkcounter_; + attachmentholders_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_attachmentholders()) { + attachmentholders_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_attachmentholders(), + GetArena()); + } + clear_has_id(); + switch (from.id_case()) { + case kBackupID: { + _internal_set_backupid(from._internal_backupid()); + break; + } + case kLogID: { + _internal_set_logid(from._internal_logid()); + break; + } + case ID_NOT_SET: { + break; + } + } clear_has_data(); switch (from.data_case()) { case kCompactionChunk: { @@ -2063,7 +2096,8 @@ } void PullBackupResponse::SharedCtor() { -chunkcounter_ = 0; +attachmentholders_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +clear_has_id(); clear_has_data(); } @@ -2075,6 +2109,10 @@ void PullBackupResponse::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); + attachmentholders_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (has_id()) { + clear_id(); + } if (has_data()) { clear_data(); } @@ -2090,6 +2128,24 @@ _cached_size_.Set(size); } +void PullBackupResponse::clear_id() { +// @@protoc_insertion_point(one_of_clear_start:backup.PullBackupResponse) + switch (id_case()) { + case kBackupID: { + id_.backupid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case kLogID: { + id_.logid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case ID_NOT_SET: { + break; + } + } + _oneof_case_[0] = ID_NOT_SET; +} + void PullBackupResponse::clear_data() { // @@protoc_insertion_point(one_of_clear_start:backup.PullBackupResponse) switch (data_case()) { @@ -2105,7 +2161,7 @@ break; } } - _oneof_case_[0] = DATA_NOT_SET; + _oneof_case_[1] = DATA_NOT_SET; } @@ -2115,38 +2171,64 @@ // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - chunkcounter_ = 0; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + attachmentholders_.ClearNonDefaultToEmpty(); + } + clear_id(); clear_data(); + _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* PullBackupResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // bytes compactionChunk = 1; + // string backupID = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - auto str = _internal_mutable_compactionchunk(); + auto str = _internal_mutable_backupid(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.PullBackupResponse.backupID")); CHK_(ptr); } else goto handle_unusual; continue; - // bytes logChunk = 2; + // string logID = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - auto str = _internal_mutable_logchunk(); + auto str = _internal_mutable_logid(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.PullBackupResponse.logID")); CHK_(ptr); } else goto handle_unusual; continue; - // int32 chunkCounter = 3; + // bytes compactionChunk = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { - chunkcounter_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_compactionchunk(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bytes logChunk = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + auto str = _internal_mutable_logchunk(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string attachmentHolders = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + auto str = _internal_mutable_attachmentholders(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.PullBackupResponse.attachmentHolders")); CHK_(ptr); } else goto handle_unusual; continue; @@ -2165,6 +2247,7 @@ } // switch } // while success: + _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; @@ -2178,22 +2261,46 @@ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // bytes compactionChunk = 1; + // string backupID = 1; + if (_internal_has_backupid()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_backupid().data(), static_cast(this->_internal_backupid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "backup.PullBackupResponse.backupID"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_backupid(), target); + } + + // string logID = 2; + if (_internal_has_logid()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_logid().data(), static_cast(this->_internal_logid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "backup.PullBackupResponse.logID"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_logid(), target); + } + + // bytes compactionChunk = 3; if (_internal_has_compactionchunk()) { target = stream->WriteBytesMaybeAliased( - 1, this->_internal_compactionchunk(), target); + 3, this->_internal_compactionchunk(), target); } - // bytes logChunk = 2; + // bytes logChunk = 4; if (_internal_has_logchunk()) { target = stream->WriteBytesMaybeAliased( - 2, this->_internal_logchunk(), target); + 4, this->_internal_logchunk(), target); } - // int32 chunkCounter = 3; - if (this->chunkcounter() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_chunkcounter(), target); + // string attachmentHolders = 5; + if (_internal_has_attachmentholders()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_attachmentholders().data(), static_cast(this->_internal_attachmentholders().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "backup.PullBackupResponse.attachmentHolders"); + target = stream->WriteStringMaybeAliased( + 5, this->_internal_attachmentholders(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -2212,22 +2319,42 @@ // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // int32 chunkCounter = 3; - if (this->chunkcounter() != 0) { + // string attachmentHolders = 5; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_chunkcounter()); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_attachmentholders()); } + switch (id_case()) { + // string backupID = 1; + case kBackupID: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_backupid()); + break; + } + // string logID = 2; + case kLogID: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_logid()); + break; + } + case ID_NOT_SET: { + break; + } + } switch (data_case()) { - // bytes compactionChunk = 1; + // bytes compactionChunk = 3; case kCompactionChunk: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( this->_internal_compactionchunk()); break; } - // bytes logChunk = 2; + // bytes logChunk = 4; case kLogChunk: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( @@ -2269,8 +2396,21 @@ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.chunkcounter() != 0) { - _internal_set_chunkcounter(from._internal_chunkcounter()); + if (from._internal_has_attachmentholders()) { + _internal_set_attachmentholders(from._internal_attachmentholders()); + } + switch (from.id_case()) { + case kBackupID: { + _internal_set_backupid(from._internal_backupid()); + break; + } + case kLogID: { + _internal_set_logid(from._internal_logid()); + break; + } + case ID_NOT_SET: { + break; + } } switch (from.data_case()) { case kCompactionChunk: { @@ -2308,9 +2448,12 @@ void PullBackupResponse::InternalSwap(PullBackupResponse* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - swap(chunkcounter_, other->chunkcounter_); + swap(_has_bits_[0], other->_has_bits_[0]); + attachmentholders_.Swap(&other->attachmentholders_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + swap(id_, other->id_); swap(data_, other->data_); swap(_oneof_case_[0], other->_oneof_case_[0]); + swap(_oneof_case_[1], other->_oneof_case_[1]); } ::PROTOBUF_NAMESPACE_ID::Metadata PullBackupResponse::GetMetadata() const { diff --git a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.h b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.h --- a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.h +++ b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.h @@ -93,14 +93,14 @@ return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::tunnelbroker::GetResponse>>(PrepareAsyncGetRaw(context, request, cq)); } // Replacing Send and Get with a single bidirectional streaming RPC - std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>> OpenStream(::grpc::ClientContext* context) { - return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>>(OpenStreamRaw(context)); + std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>> MessagesStream(::grpc::ClientContext* context) { + return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>>(MessagesStreamRaw(context)); } - std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>> AsyncOpenStream(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { - return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>>(AsyncOpenStreamRaw(context, cq, tag)); + std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>> AsyncMessagesStream(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>>(AsyncMessagesStreamRaw(context, cq, tag)); } - std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>> PrepareAsyncOpenStream(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>>(PrepareAsyncOpenStreamRaw(context, cq)); + std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>> PrepareAsyncMessagesStream(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>>(PrepareAsyncMessagesStreamRaw(context, cq)); } class async_interface { public: @@ -125,7 +125,7 @@ virtual void Send(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void Get(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest* request, ::grpc::ClientReadReactor< ::tunnelbroker::GetResponse>* reactor) = 0; // Replacing Send and Get with a single bidirectional streaming RPC - virtual void OpenStream(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::tunnelbroker::OutboundMessage,::tunnelbroker::InboundMessage>* reactor) = 0; + virtual void MessagesStream(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::tunnelbroker::MessageToTunnelbroker,::tunnelbroker::MessageToClient>* reactor) = 0; }; typedef class async_interface experimental_async_interface; virtual class async_interface* async() { return nullptr; } @@ -146,9 +146,9 @@ virtual ::grpc::ClientReaderInterface< ::tunnelbroker::GetResponse>* GetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request) = 0; virtual ::grpc::ClientAsyncReaderInterface< ::tunnelbroker::GetResponse>* AsyncGetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq, void* tag) = 0; virtual ::grpc::ClientAsyncReaderInterface< ::tunnelbroker::GetResponse>* PrepareAsyncGetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* OpenStreamRaw(::grpc::ClientContext* context) = 0; - virtual ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* AsyncOpenStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0; - virtual ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* PrepareAsyncOpenStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientReaderWriterInterface< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>* MessagesStreamRaw(::grpc::ClientContext* context) = 0; + virtual ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>* AsyncMessagesStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0; + virtual ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>* PrepareAsyncMessagesStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0; }; class Stub final : public StubInterface { public: @@ -204,14 +204,14 @@ std::unique_ptr< ::grpc::ClientAsyncReader< ::tunnelbroker::GetResponse>> PrepareAsyncGet(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReader< ::tunnelbroker::GetResponse>>(PrepareAsyncGetRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>> OpenStream(::grpc::ClientContext* context) { - return std::unique_ptr< ::grpc::ClientReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>>(OpenStreamRaw(context)); + std::unique_ptr< ::grpc::ClientReaderWriter< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>> MessagesStream(::grpc::ClientContext* context) { + return std::unique_ptr< ::grpc::ClientReaderWriter< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>>(MessagesStreamRaw(context)); } - std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>> AsyncOpenStream(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { - return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>>(AsyncOpenStreamRaw(context, cq, tag)); + std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>> AsyncMessagesStream(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>>(AsyncMessagesStreamRaw(context, cq, tag)); } - std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>> PrepareAsyncOpenStream(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>>(PrepareAsyncOpenStreamRaw(context, cq)); + std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>> PrepareAsyncMessagesStream(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>>(PrepareAsyncMessagesStreamRaw(context, cq)); } class async final : public StubInterface::async_interface { @@ -229,7 +229,7 @@ void Send(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest* request, ::google::protobuf::Empty* response, std::function) override; void Send(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) override; void Get(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest* request, ::grpc::ClientReadReactor< ::tunnelbroker::GetResponse>* reactor) override; - void OpenStream(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::tunnelbroker::OutboundMessage,::tunnelbroker::InboundMessage>* reactor) override; + void MessagesStream(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::tunnelbroker::MessageToTunnelbroker,::tunnelbroker::MessageToClient>* reactor) override; private: friend class Stub; explicit async(Stub* stub): stub_(stub) { } @@ -256,9 +256,9 @@ ::grpc::ClientReader< ::tunnelbroker::GetResponse>* GetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request) override; ::grpc::ClientAsyncReader< ::tunnelbroker::GetResponse>* AsyncGetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq, void* tag) override; ::grpc::ClientAsyncReader< ::tunnelbroker::GetResponse>* PrepareAsyncGetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* OpenStreamRaw(::grpc::ClientContext* context) override; - ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* AsyncOpenStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override; - ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* PrepareAsyncOpenStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientReaderWriter< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>* MessagesStreamRaw(::grpc::ClientContext* context) override; + ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>* AsyncMessagesStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override; + ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>* PrepareAsyncMessagesStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override; const ::grpc::internal::RpcMethod rpcmethod_CheckIfPrimaryDeviceOnline_; const ::grpc::internal::RpcMethod rpcmethod_BecomeNewPrimaryDevice_; const ::grpc::internal::RpcMethod rpcmethod_SendPong_; @@ -266,7 +266,7 @@ const ::grpc::internal::RpcMethod rpcmethod_NewSession_; const ::grpc::internal::RpcMethod rpcmethod_Send_; const ::grpc::internal::RpcMethod rpcmethod_Get_; - const ::grpc::internal::RpcMethod rpcmethod_OpenStream_; + const ::grpc::internal::RpcMethod rpcmethod_MessagesStream_; }; static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); @@ -288,7 +288,7 @@ virtual ::grpc::Status Send(::grpc::ServerContext* context, const ::tunnelbroker::SendRequest* request, ::google::protobuf::Empty* response); virtual ::grpc::Status Get(::grpc::ServerContext* context, const ::tunnelbroker::GetRequest* request, ::grpc::ServerWriter< ::tunnelbroker::GetResponse>* writer); // Replacing Send and Get with a single bidirectional streaming RPC - virtual ::grpc::Status OpenStream(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* stream); + virtual ::grpc::Status MessagesStream(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::tunnelbroker::MessageToClient, ::tunnelbroker::MessageToTunnelbroker>* stream); }; template class WithAsyncMethod_CheckIfPrimaryDeviceOnline : public BaseClass { @@ -431,26 +431,26 @@ } }; template - class WithAsyncMethod_OpenStream : public BaseClass { + class WithAsyncMethod_MessagesStream : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithAsyncMethod_OpenStream() { + WithAsyncMethod_MessagesStream() { ::grpc::Service::MarkMethodAsync(7); } - ~WithAsyncMethod_OpenStream() override { + ~WithAsyncMethod_MessagesStream() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status OpenStream(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* /*stream*/) override { + ::grpc::Status MessagesStream(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tunnelbroker::MessageToClient, ::tunnelbroker::MessageToTunnelbroker>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestOpenStream(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestMessagesStream(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::tunnelbroker::MessageToClient, ::tunnelbroker::MessageToTunnelbroker>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncBidiStreaming(7, context, stream, new_call_cq, notification_cq, tag); } }; - typedef WithAsyncMethod_CheckIfPrimaryDeviceOnline > > > > > > > AsyncService; + typedef WithAsyncMethod_CheckIfPrimaryDeviceOnline > > > > > > > AsyncService; template class WithCallbackMethod_CheckIfPrimaryDeviceOnline : public BaseClass { private: @@ -636,29 +636,29 @@ ::grpc::CallbackServerContext* /*context*/, const ::tunnelbroker::GetRequest* /*request*/) { return nullptr; } }; template - class WithCallbackMethod_OpenStream : public BaseClass { + class WithCallbackMethod_MessagesStream : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithCallbackMethod_OpenStream() { + WithCallbackMethod_MessagesStream() { ::grpc::Service::MarkMethodCallback(7, - new ::grpc::internal::CallbackBidiHandler< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>( + new ::grpc::internal::CallbackBidiHandler< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>( [this]( - ::grpc::CallbackServerContext* context) { return this->OpenStream(context); })); + ::grpc::CallbackServerContext* context) { return this->MessagesStream(context); })); } - ~WithCallbackMethod_OpenStream() override { + ~WithCallbackMethod_MessagesStream() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status OpenStream(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* /*stream*/) override { + ::grpc::Status MessagesStream(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tunnelbroker::MessageToClient, ::tunnelbroker::MessageToTunnelbroker>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual ::grpc::ServerBidiReactor< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* OpenStream( + virtual ::grpc::ServerBidiReactor< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>* MessagesStream( ::grpc::CallbackServerContext* /*context*/) { return nullptr; } }; - typedef WithCallbackMethod_CheckIfPrimaryDeviceOnline > > > > > > > CallbackService; + typedef WithCallbackMethod_CheckIfPrimaryDeviceOnline > > > > > > > CallbackService; typedef CallbackService ExperimentalCallbackService; template class WithGenericMethod_CheckIfPrimaryDeviceOnline : public BaseClass { @@ -780,18 +780,18 @@ } }; template - class WithGenericMethod_OpenStream : public BaseClass { + class WithGenericMethod_MessagesStream : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithGenericMethod_OpenStream() { + WithGenericMethod_MessagesStream() { ::grpc::Service::MarkMethodGeneric(7); } - ~WithGenericMethod_OpenStream() override { + ~WithGenericMethod_MessagesStream() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status OpenStream(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* /*stream*/) override { + ::grpc::Status MessagesStream(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tunnelbroker::MessageToClient, ::tunnelbroker::MessageToTunnelbroker>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -937,22 +937,22 @@ } }; template - class WithRawMethod_OpenStream : public BaseClass { + class WithRawMethod_MessagesStream : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithRawMethod_OpenStream() { + WithRawMethod_MessagesStream() { ::grpc::Service::MarkMethodRaw(7); } - ~WithRawMethod_OpenStream() override { + ~WithRawMethod_MessagesStream() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status OpenStream(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* /*stream*/) override { + ::grpc::Status MessagesStream(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tunnelbroker::MessageToClient, ::tunnelbroker::MessageToTunnelbroker>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestOpenStream(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestMessagesStream(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncBidiStreaming(7, context, stream, new_call_cq, notification_cq, tag); } }; @@ -1111,25 +1111,25 @@ ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/) { return nullptr; } }; template - class WithRawCallbackMethod_OpenStream : public BaseClass { + class WithRawCallbackMethod_MessagesStream : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithRawCallbackMethod_OpenStream() { + WithRawCallbackMethod_MessagesStream() { ::grpc::Service::MarkMethodRawCallback(7, new ::grpc::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( - ::grpc::CallbackServerContext* context) { return this->OpenStream(context); })); + ::grpc::CallbackServerContext* context) { return this->MessagesStream(context); })); } - ~WithRawCallbackMethod_OpenStream() override { + ~WithRawCallbackMethod_MessagesStream() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status OpenStream(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* /*stream*/) override { + ::grpc::Status MessagesStream(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tunnelbroker::MessageToClient, ::tunnelbroker::MessageToTunnelbroker>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* OpenStream( + virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* MessagesStream( ::grpc::CallbackServerContext* /*context*/) { return nullptr; } }; diff --git a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.cc b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.cc --- a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.cc +++ b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.cc @@ -29,7 +29,7 @@ "/tunnelbroker.TunnelbrokerService/NewSession", "/tunnelbroker.TunnelbrokerService/Send", "/tunnelbroker.TunnelbrokerService/Get", - "/tunnelbroker.TunnelbrokerService/OpenStream", + "/tunnelbroker.TunnelbrokerService/MessagesStream", }; std::unique_ptr< TunnelbrokerService::Stub> TunnelbrokerService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) { @@ -46,7 +46,7 @@ , rpcmethod_NewSession_(TunnelbrokerService_method_names[4], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_Send_(TunnelbrokerService_method_names[5], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_Get_(TunnelbrokerService_method_names[6], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel) - , rpcmethod_OpenStream_(TunnelbrokerService_method_names[7], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel) + , rpcmethod_MessagesStream_(TunnelbrokerService_method_names[7], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel) {} ::grpc::Status TunnelbrokerService::Stub::CheckIfPrimaryDeviceOnline(::grpc::ClientContext* context, const ::tunnelbroker::CheckRequest& request, ::tunnelbroker::CheckResponse* response) { @@ -203,20 +203,20 @@ return ::grpc::internal::ClientAsyncReaderFactory< ::tunnelbroker::GetResponse>::Create(channel_.get(), cq, rpcmethod_Get_, context, request, false, nullptr); } -::grpc::ClientReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* TunnelbrokerService::Stub::OpenStreamRaw(::grpc::ClientContext* context) { - return ::grpc::internal::ClientReaderWriterFactory< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>::Create(channel_.get(), rpcmethod_OpenStream_, context); +::grpc::ClientReaderWriter< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>* TunnelbrokerService::Stub::MessagesStreamRaw(::grpc::ClientContext* context) { + return ::grpc::internal::ClientReaderWriterFactory< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>::Create(channel_.get(), rpcmethod_MessagesStream_, context); } -void TunnelbrokerService::Stub::async::OpenStream(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::tunnelbroker::OutboundMessage,::tunnelbroker::InboundMessage>* reactor) { - ::grpc::internal::ClientCallbackReaderWriterFactory< ::tunnelbroker::OutboundMessage,::tunnelbroker::InboundMessage>::Create(stub_->channel_.get(), stub_->rpcmethod_OpenStream_, context, reactor); +void TunnelbrokerService::Stub::async::MessagesStream(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::tunnelbroker::MessageToTunnelbroker,::tunnelbroker::MessageToClient>* reactor) { + ::grpc::internal::ClientCallbackReaderWriterFactory< ::tunnelbroker::MessageToTunnelbroker,::tunnelbroker::MessageToClient>::Create(stub_->channel_.get(), stub_->rpcmethod_MessagesStream_, context, reactor); } -::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* TunnelbrokerService::Stub::AsyncOpenStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { - return ::grpc::internal::ClientAsyncReaderWriterFactory< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>::Create(channel_.get(), cq, rpcmethod_OpenStream_, context, true, tag); +::grpc::ClientAsyncReaderWriter< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>* TunnelbrokerService::Stub::AsyncMessagesStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return ::grpc::internal::ClientAsyncReaderWriterFactory< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>::Create(channel_.get(), cq, rpcmethod_MessagesStream_, context, true, tag); } -::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* TunnelbrokerService::Stub::PrepareAsyncOpenStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { - return ::grpc::internal::ClientAsyncReaderWriterFactory< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>::Create(channel_.get(), cq, rpcmethod_OpenStream_, context, false, nullptr); +::grpc::ClientAsyncReaderWriter< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>* TunnelbrokerService::Stub::PrepareAsyncMessagesStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncReaderWriterFactory< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>::Create(channel_.get(), cq, rpcmethod_MessagesStream_, context, false, nullptr); } TunnelbrokerService::Service::Service() { @@ -293,12 +293,12 @@ AddMethod(new ::grpc::internal::RpcServiceMethod( TunnelbrokerService_method_names[7], ::grpc::internal::RpcMethod::BIDI_STREAMING, - new ::grpc::internal::BidiStreamingHandler< TunnelbrokerService::Service, ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>( + new ::grpc::internal::BidiStreamingHandler< TunnelbrokerService::Service, ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>( [](TunnelbrokerService::Service* service, ::grpc::ServerContext* ctx, - ::grpc::ServerReaderWriter<::tunnelbroker::InboundMessage, - ::tunnelbroker::OutboundMessage>* stream) { - return service->OpenStream(ctx, stream); + ::grpc::ServerReaderWriter<::tunnelbroker::MessageToClient, + ::tunnelbroker::MessageToTunnelbroker>* stream) { + return service->MessagesStream(ctx, stream); }, this))); } @@ -354,7 +354,7 @@ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status TunnelbrokerService::Service::OpenStream(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* stream) { +::grpc::Status TunnelbrokerService::Service::MessagesStream(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::tunnelbroker::MessageToClient, ::tunnelbroker::MessageToTunnelbroker>* stream) { (void) context; (void) stream; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); diff --git a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.h b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.h --- a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.h +++ b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.h @@ -48,7 +48,7 @@ PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[14] + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[19] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; @@ -69,9 +69,24 @@ class GetResponse; struct GetResponseDefaultTypeInternal; extern GetResponseDefaultTypeInternal _GetResponse_default_instance_; -class InboundMessage; -struct InboundMessageDefaultTypeInternal; -extern InboundMessageDefaultTypeInternal _InboundMessage_default_instance_; +class MessageToClient; +struct MessageToClientDefaultTypeInternal; +extern MessageToClientDefaultTypeInternal _MessageToClient_default_instance_; +class MessageToClientStruct; +struct MessageToClientStructDefaultTypeInternal; +extern MessageToClientStructDefaultTypeInternal _MessageToClientStruct_default_instance_; +class MessageToTunnelbroker; +struct MessageToTunnelbrokerDefaultTypeInternal; +extern MessageToTunnelbrokerDefaultTypeInternal _MessageToTunnelbroker_default_instance_; +class MessageToTunnelbrokerStruct; +struct MessageToTunnelbrokerStructDefaultTypeInternal; +extern MessageToTunnelbrokerStructDefaultTypeInternal _MessageToTunnelbrokerStruct_default_instance_; +class MessagesToDeliver; +struct MessagesToDeliverDefaultTypeInternal; +extern MessagesToDeliverDefaultTypeInternal _MessagesToDeliver_default_instance_; +class MessagesToSend; +struct MessagesToSendDefaultTypeInternal; +extern MessagesToSendDefaultTypeInternal _MessagesToSend_default_instance_; class NewPrimaryRequest; struct NewPrimaryRequestDefaultTypeInternal; extern NewPrimaryRequestDefaultTypeInternal _NewPrimaryRequest_default_instance_; @@ -84,12 +99,12 @@ class NewSessionResponse; struct NewSessionResponseDefaultTypeInternal; extern NewSessionResponseDefaultTypeInternal _NewSessionResponse_default_instance_; -class OutboundMessage; -struct OutboundMessageDefaultTypeInternal; -extern OutboundMessageDefaultTypeInternal _OutboundMessage_default_instance_; class PongRequest; struct PongRequestDefaultTypeInternal; extern PongRequestDefaultTypeInternal _PongRequest_default_instance_; +class ProcessedMessages; +struct ProcessedMessagesDefaultTypeInternal; +extern ProcessedMessagesDefaultTypeInternal _ProcessedMessages_default_instance_; class SendRequest; struct SendRequestDefaultTypeInternal; extern SendRequestDefaultTypeInternal _SendRequest_default_instance_; @@ -105,13 +120,18 @@ template<> ::tunnelbroker::CheckResponse* Arena::CreateMaybeMessage<::tunnelbroker::CheckResponse>(Arena*); template<> ::tunnelbroker::GetRequest* Arena::CreateMaybeMessage<::tunnelbroker::GetRequest>(Arena*); template<> ::tunnelbroker::GetResponse* Arena::CreateMaybeMessage<::tunnelbroker::GetResponse>(Arena*); -template<> ::tunnelbroker::InboundMessage* Arena::CreateMaybeMessage<::tunnelbroker::InboundMessage>(Arena*); +template<> ::tunnelbroker::MessageToClient* Arena::CreateMaybeMessage<::tunnelbroker::MessageToClient>(Arena*); +template<> ::tunnelbroker::MessageToClientStruct* Arena::CreateMaybeMessage<::tunnelbroker::MessageToClientStruct>(Arena*); +template<> ::tunnelbroker::MessageToTunnelbroker* Arena::CreateMaybeMessage<::tunnelbroker::MessageToTunnelbroker>(Arena*); +template<> ::tunnelbroker::MessageToTunnelbrokerStruct* Arena::CreateMaybeMessage<::tunnelbroker::MessageToTunnelbrokerStruct>(Arena*); +template<> ::tunnelbroker::MessagesToDeliver* Arena::CreateMaybeMessage<::tunnelbroker::MessagesToDeliver>(Arena*); +template<> ::tunnelbroker::MessagesToSend* Arena::CreateMaybeMessage<::tunnelbroker::MessagesToSend>(Arena*); template<> ::tunnelbroker::NewPrimaryRequest* Arena::CreateMaybeMessage<::tunnelbroker::NewPrimaryRequest>(Arena*); template<> ::tunnelbroker::NewPrimaryResponse* Arena::CreateMaybeMessage<::tunnelbroker::NewPrimaryResponse>(Arena*); template<> ::tunnelbroker::NewSessionRequest* Arena::CreateMaybeMessage<::tunnelbroker::NewSessionRequest>(Arena*); template<> ::tunnelbroker::NewSessionResponse* Arena::CreateMaybeMessage<::tunnelbroker::NewSessionResponse>(Arena*); -template<> ::tunnelbroker::OutboundMessage* Arena::CreateMaybeMessage<::tunnelbroker::OutboundMessage>(Arena*); template<> ::tunnelbroker::PongRequest* Arena::CreateMaybeMessage<::tunnelbroker::PongRequest>(Arena*); +template<> ::tunnelbroker::ProcessedMessages* Arena::CreateMaybeMessage<::tunnelbroker::ProcessedMessages>(Arena*); template<> ::tunnelbroker::SendRequest* Arena::CreateMaybeMessage<::tunnelbroker::SendRequest>(Arena*); template<> ::tunnelbroker::SessionSignatureRequest* Arena::CreateMaybeMessage<::tunnelbroker::SessionSignatureRequest>(Arena*); template<> ::tunnelbroker::SessionSignatureResponse* Arena::CreateMaybeMessage<::tunnelbroker::SessionSignatureResponse>(Arena*); @@ -1425,24 +1445,24 @@ }; // ------------------------------------------------------------------- -class OutboundMessage PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.OutboundMessage) */ { +class ProcessedMessages PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.ProcessedMessages) */ { public: - inline OutboundMessage() : OutboundMessage(nullptr) {} - virtual ~OutboundMessage(); - explicit constexpr OutboundMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + inline ProcessedMessages() : ProcessedMessages(nullptr) {} + virtual ~ProcessedMessages(); + explicit constexpr ProcessedMessages(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - OutboundMessage(const OutboundMessage& from); - OutboundMessage(OutboundMessage&& from) noexcept - : OutboundMessage() { + ProcessedMessages(const ProcessedMessages& from); + ProcessedMessages(ProcessedMessages&& from) noexcept + : ProcessedMessages() { *this = ::std::move(from); } - inline OutboundMessage& operator=(const OutboundMessage& from) { + inline ProcessedMessages& operator=(const ProcessedMessages& from) { CopyFrom(from); return *this; } - inline OutboundMessage& operator=(OutboundMessage&& from) noexcept { + inline ProcessedMessages& operator=(ProcessedMessages&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { @@ -1460,20 +1480,20 @@ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } - static const OutboundMessage& default_instance() { + static const ProcessedMessages& default_instance() { return *internal_default_instance(); } - static inline const OutboundMessage* internal_default_instance() { - return reinterpret_cast( - &_OutboundMessage_default_instance_); + static inline const ProcessedMessages* internal_default_instance() { + return reinterpret_cast( + &_ProcessedMessages_default_instance_); } static constexpr int kIndexInFileMessages = 7; - friend void swap(OutboundMessage& a, OutboundMessage& b) { + friend void swap(ProcessedMessages& a, ProcessedMessages& b) { a.Swap(&b); } - inline void Swap(OutboundMessage* other) { + inline void Swap(ProcessedMessages* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); @@ -1481,7 +1501,7 @@ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(OutboundMessage* other) { + void UnsafeArenaSwap(ProcessedMessages* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1489,17 +1509,17 @@ // implements Message ---------------------------------------------- - inline OutboundMessage* New() const final { - return CreateMaybeMessage(nullptr); + inline ProcessedMessages* New() const final { + return CreateMaybeMessage(nullptr); } - OutboundMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + ProcessedMessages* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const OutboundMessage& from); - void MergeFrom(const OutboundMessage& from); + void CopyFrom(const ProcessedMessages& from); + void MergeFrom(const ProcessedMessages& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -1513,13 +1533,13 @@ inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(OutboundMessage* other); + void InternalSwap(ProcessedMessages* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "tunnelbroker.OutboundMessage"; + return "tunnelbroker.ProcessedMessages"; } protected: - explicit OutboundMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit ProcessedMessages(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1538,11 +1558,719 @@ // accessors ------------------------------------------------------- enum : int { - kBlobHashesFieldNumber = 3, - kToDeviceIDFieldNumber = 1, - kPayloadFieldNumber = 2, + kMessageIDFieldNumber = 1, + }; + // repeated string messageID = 1; + int messageid_size() const; + private: + int _internal_messageid_size() const; + public: + void clear_messageid(); + const std::string& messageid(int index) const; + std::string* mutable_messageid(int index); + void set_messageid(int index, const std::string& value); + void set_messageid(int index, std::string&& value); + void set_messageid(int index, const char* value); + void set_messageid(int index, const char* value, size_t size); + std::string* add_messageid(); + void add_messageid(const std::string& value); + void add_messageid(std::string&& value); + void add_messageid(const char* value); + void add_messageid(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& messageid() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_messageid(); + private: + const std::string& _internal_messageid(int index) const; + std::string* _internal_add_messageid(); + public: + + // @@protoc_insertion_point(class_scope:tunnelbroker.ProcessedMessages) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField messageid_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_tunnelbroker_2eproto; +}; +// ------------------------------------------------------------------- + +class MessageToTunnelbrokerStruct PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.MessageToTunnelbrokerStruct) */ { + public: + inline MessageToTunnelbrokerStruct() : MessageToTunnelbrokerStruct(nullptr) {} + virtual ~MessageToTunnelbrokerStruct(); + explicit constexpr MessageToTunnelbrokerStruct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MessageToTunnelbrokerStruct(const MessageToTunnelbrokerStruct& from); + MessageToTunnelbrokerStruct(MessageToTunnelbrokerStruct&& from) noexcept + : MessageToTunnelbrokerStruct() { + *this = ::std::move(from); + } + + inline MessageToTunnelbrokerStruct& operator=(const MessageToTunnelbrokerStruct& from) { + CopyFrom(from); + return *this; + } + inline MessageToTunnelbrokerStruct& operator=(MessageToTunnelbrokerStruct&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const MessageToTunnelbrokerStruct& default_instance() { + return *internal_default_instance(); + } + static inline const MessageToTunnelbrokerStruct* internal_default_instance() { + return reinterpret_cast( + &_MessageToTunnelbrokerStruct_default_instance_); + } + static constexpr int kIndexInFileMessages = + 8; + + friend void swap(MessageToTunnelbrokerStruct& a, MessageToTunnelbrokerStruct& b) { + a.Swap(&b); + } + inline void Swap(MessageToTunnelbrokerStruct* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MessageToTunnelbrokerStruct* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline MessageToTunnelbrokerStruct* New() const final { + return CreateMaybeMessage(nullptr); + } + + MessageToTunnelbrokerStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const MessageToTunnelbrokerStruct& from); + void MergeFrom(const MessageToTunnelbrokerStruct& 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(MessageToTunnelbrokerStruct* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "tunnelbroker.MessageToTunnelbrokerStruct"; + } + protected: + explicit MessageToTunnelbrokerStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages); + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kBlobHashesFieldNumber = 4, + kMessageIDFieldNumber = 1, + kToDeviceIDFieldNumber = 2, + kPayloadFieldNumber = 3, + }; + // repeated string blobHashes = 4; + int blobhashes_size() const; + private: + int _internal_blobhashes_size() const; + public: + void clear_blobhashes(); + const std::string& blobhashes(int index) const; + std::string* mutable_blobhashes(int index); + void set_blobhashes(int index, const std::string& value); + void set_blobhashes(int index, std::string&& value); + void set_blobhashes(int index, const char* value); + void set_blobhashes(int index, const char* value, size_t size); + std::string* add_blobhashes(); + void add_blobhashes(const std::string& value); + void add_blobhashes(std::string&& value); + void add_blobhashes(const char* value); + void add_blobhashes(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& blobhashes() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_blobhashes(); + private: + const std::string& _internal_blobhashes(int index) const; + std::string* _internal_add_blobhashes(); + public: + + // string messageID = 1; + void clear_messageid(); + const std::string& messageid() const; + void set_messageid(const std::string& value); + void set_messageid(std::string&& value); + void set_messageid(const char* value); + void set_messageid(const char* value, size_t size); + std::string* mutable_messageid(); + std::string* release_messageid(); + void set_allocated_messageid(std::string* messageid); + private: + const std::string& _internal_messageid() const; + void _internal_set_messageid(const std::string& value); + std::string* _internal_mutable_messageid(); + public: + + // string toDeviceID = 2; + void clear_todeviceid(); + const std::string& todeviceid() const; + void set_todeviceid(const std::string& value); + void set_todeviceid(std::string&& value); + void set_todeviceid(const char* value); + void set_todeviceid(const char* value, size_t size); + std::string* mutable_todeviceid(); + std::string* release_todeviceid(); + void set_allocated_todeviceid(std::string* todeviceid); + private: + const std::string& _internal_todeviceid() const; + void _internal_set_todeviceid(const std::string& value); + std::string* _internal_mutable_todeviceid(); + public: + + // string payload = 3; + void clear_payload(); + const std::string& payload() const; + void set_payload(const std::string& value); + void set_payload(std::string&& value); + void set_payload(const char* value); + void set_payload(const char* value, size_t size); + std::string* mutable_payload(); + std::string* release_payload(); + void set_allocated_payload(std::string* payload); + private: + const std::string& _internal_payload() const; + void _internal_set_payload(const std::string& value); + std::string* _internal_mutable_payload(); + public: + + // @@protoc_insertion_point(class_scope:tunnelbroker.MessageToTunnelbrokerStruct) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField blobhashes_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr messageid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr todeviceid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_tunnelbroker_2eproto; +}; +// ------------------------------------------------------------------- + +class MessagesToSend PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.MessagesToSend) */ { + public: + inline MessagesToSend() : MessagesToSend(nullptr) {} + virtual ~MessagesToSend(); + explicit constexpr MessagesToSend(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MessagesToSend(const MessagesToSend& from); + MessagesToSend(MessagesToSend&& from) noexcept + : MessagesToSend() { + *this = ::std::move(from); + } + + inline MessagesToSend& operator=(const MessagesToSend& from) { + CopyFrom(from); + return *this; + } + inline MessagesToSend& operator=(MessagesToSend&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const MessagesToSend& default_instance() { + return *internal_default_instance(); + } + static inline const MessagesToSend* internal_default_instance() { + return reinterpret_cast( + &_MessagesToSend_default_instance_); + } + static constexpr int kIndexInFileMessages = + 9; + + friend void swap(MessagesToSend& a, MessagesToSend& b) { + a.Swap(&b); + } + inline void Swap(MessagesToSend* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MessagesToSend* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline MessagesToSend* New() const final { + return CreateMaybeMessage(nullptr); + } + + MessagesToSend* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const MessagesToSend& from); + void MergeFrom(const MessagesToSend& 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(MessagesToSend* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "tunnelbroker.MessagesToSend"; + } + protected: + explicit MessagesToSend(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages); + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMessagesFieldNumber = 1, + }; + // repeated .tunnelbroker.MessageToTunnelbrokerStruct messages = 1; + int messages_size() const; + private: + int _internal_messages_size() const; + public: + void clear_messages(); + ::tunnelbroker::MessageToTunnelbrokerStruct* mutable_messages(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tunnelbroker::MessageToTunnelbrokerStruct >* + mutable_messages(); + private: + const ::tunnelbroker::MessageToTunnelbrokerStruct& _internal_messages(int index) const; + ::tunnelbroker::MessageToTunnelbrokerStruct* _internal_add_messages(); + public: + const ::tunnelbroker::MessageToTunnelbrokerStruct& messages(int index) const; + ::tunnelbroker::MessageToTunnelbrokerStruct* add_messages(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tunnelbroker::MessageToTunnelbrokerStruct >& + messages() const; + + // @@protoc_insertion_point(class_scope:tunnelbroker.MessagesToSend) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tunnelbroker::MessageToTunnelbrokerStruct > messages_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_tunnelbroker_2eproto; +}; +// ------------------------------------------------------------------- + +class MessageToTunnelbroker PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.MessageToTunnelbroker) */ { + public: + inline MessageToTunnelbroker() : MessageToTunnelbroker(nullptr) {} + virtual ~MessageToTunnelbroker(); + explicit constexpr MessageToTunnelbroker(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MessageToTunnelbroker(const MessageToTunnelbroker& from); + MessageToTunnelbroker(MessageToTunnelbroker&& from) noexcept + : MessageToTunnelbroker() { + *this = ::std::move(from); + } + + inline MessageToTunnelbroker& operator=(const MessageToTunnelbroker& from) { + CopyFrom(from); + return *this; + } + inline MessageToTunnelbroker& operator=(MessageToTunnelbroker&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const MessageToTunnelbroker& default_instance() { + return *internal_default_instance(); + } + enum DataCase { + kMessagesToSend = 2, + kProcessedMessages = 3, + DATA_NOT_SET = 0, + }; + + static inline const MessageToTunnelbroker* internal_default_instance() { + return reinterpret_cast( + &_MessageToTunnelbroker_default_instance_); + } + static constexpr int kIndexInFileMessages = + 10; + + friend void swap(MessageToTunnelbroker& a, MessageToTunnelbroker& b) { + a.Swap(&b); + } + inline void Swap(MessageToTunnelbroker* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MessageToTunnelbroker* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline MessageToTunnelbroker* New() const final { + return CreateMaybeMessage(nullptr); + } + + MessageToTunnelbroker* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const MessageToTunnelbroker& from); + void MergeFrom(const MessageToTunnelbroker& 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(MessageToTunnelbroker* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "tunnelbroker.MessageToTunnelbroker"; + } + protected: + explicit MessageToTunnelbroker(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages); + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSessionIDFieldNumber = 1, + kMessagesToSendFieldNumber = 2, + kProcessedMessagesFieldNumber = 3, + }; + // string sessionID = 1; + void clear_sessionid(); + const std::string& sessionid() const; + void set_sessionid(const std::string& value); + void set_sessionid(std::string&& value); + void set_sessionid(const char* value); + void set_sessionid(const char* value, size_t size); + std::string* mutable_sessionid(); + std::string* release_sessionid(); + void set_allocated_sessionid(std::string* sessionid); + private: + const std::string& _internal_sessionid() const; + void _internal_set_sessionid(const std::string& value); + std::string* _internal_mutable_sessionid(); + public: + + // .tunnelbroker.MessagesToSend messagesToSend = 2; + bool has_messagestosend() const; + private: + bool _internal_has_messagestosend() const; + public: + void clear_messagestosend(); + const ::tunnelbroker::MessagesToSend& messagestosend() const; + ::tunnelbroker::MessagesToSend* release_messagestosend(); + ::tunnelbroker::MessagesToSend* mutable_messagestosend(); + void set_allocated_messagestosend(::tunnelbroker::MessagesToSend* messagestosend); + private: + const ::tunnelbroker::MessagesToSend& _internal_messagestosend() const; + ::tunnelbroker::MessagesToSend* _internal_mutable_messagestosend(); + public: + void unsafe_arena_set_allocated_messagestosend( + ::tunnelbroker::MessagesToSend* messagestosend); + ::tunnelbroker::MessagesToSend* unsafe_arena_release_messagestosend(); + + // .tunnelbroker.ProcessedMessages processedMessages = 3; + bool has_processedmessages() const; + private: + bool _internal_has_processedmessages() const; + public: + void clear_processedmessages(); + const ::tunnelbroker::ProcessedMessages& processedmessages() const; + ::tunnelbroker::ProcessedMessages* release_processedmessages(); + ::tunnelbroker::ProcessedMessages* mutable_processedmessages(); + void set_allocated_processedmessages(::tunnelbroker::ProcessedMessages* processedmessages); + private: + const ::tunnelbroker::ProcessedMessages& _internal_processedmessages() const; + ::tunnelbroker::ProcessedMessages* _internal_mutable_processedmessages(); + public: + void unsafe_arena_set_allocated_processedmessages( + ::tunnelbroker::ProcessedMessages* processedmessages); + ::tunnelbroker::ProcessedMessages* unsafe_arena_release_processedmessages(); + + void clear_data(); + DataCase data_case() const; + // @@protoc_insertion_point(class_scope:tunnelbroker.MessageToTunnelbroker) + private: + class _Internal; + void set_has_messagestosend(); + void set_has_processedmessages(); + + inline bool has_data() const; + inline void clear_has_data(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sessionid_; + union DataUnion { + constexpr DataUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::tunnelbroker::MessagesToSend* messagestosend_; + ::tunnelbroker::ProcessedMessages* processedmessages_; + } data_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_tunnelbroker_2eproto; +}; +// ------------------------------------------------------------------- + +class MessageToClientStruct PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.MessageToClientStruct) */ { + public: + inline MessageToClientStruct() : MessageToClientStruct(nullptr) {} + virtual ~MessageToClientStruct(); + explicit constexpr MessageToClientStruct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MessageToClientStruct(const MessageToClientStruct& from); + MessageToClientStruct(MessageToClientStruct&& from) noexcept + : MessageToClientStruct() { + *this = ::std::move(from); + } + + inline MessageToClientStruct& operator=(const MessageToClientStruct& from) { + CopyFrom(from); + return *this; + } + inline MessageToClientStruct& operator=(MessageToClientStruct&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const MessageToClientStruct& default_instance() { + return *internal_default_instance(); + } + static inline const MessageToClientStruct* internal_default_instance() { + return reinterpret_cast( + &_MessageToClientStruct_default_instance_); + } + static constexpr int kIndexInFileMessages = + 11; + + friend void swap(MessageToClientStruct& a, MessageToClientStruct& b) { + a.Swap(&b); + } + inline void Swap(MessageToClientStruct* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MessageToClientStruct* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline MessageToClientStruct* New() const final { + return CreateMaybeMessage(nullptr); + } + + MessageToClientStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const MessageToClientStruct& from); + void MergeFrom(const MessageToClientStruct& 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(MessageToClientStruct* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "tunnelbroker.MessageToClientStruct"; + } + protected: + explicit MessageToClientStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages); + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kBlobHashesFieldNumber = 4, + kMessageIDFieldNumber = 1, + kFromDeviceIDFieldNumber = 2, + kPayloadFieldNumber = 3, }; - // repeated string blobHashes = 3; + // repeated string blobHashes = 4; int blobhashes_size() const; private: int _internal_blobhashes_size() const; @@ -1566,23 +2294,39 @@ std::string* _internal_add_blobhashes(); public: - // string toDeviceID = 1; - void clear_todeviceid(); - const std::string& todeviceid() const; - void set_todeviceid(const std::string& value); - void set_todeviceid(std::string&& value); - void set_todeviceid(const char* value); - void set_todeviceid(const char* value, size_t size); - std::string* mutable_todeviceid(); - std::string* release_todeviceid(); - void set_allocated_todeviceid(std::string* todeviceid); + // string messageID = 1; + void clear_messageid(); + const std::string& messageid() const; + void set_messageid(const std::string& value); + void set_messageid(std::string&& value); + void set_messageid(const char* value); + void set_messageid(const char* value, size_t size); + std::string* mutable_messageid(); + std::string* release_messageid(); + void set_allocated_messageid(std::string* messageid); private: - const std::string& _internal_todeviceid() const; - void _internal_set_todeviceid(const std::string& value); - std::string* _internal_mutable_todeviceid(); + const std::string& _internal_messageid() const; + void _internal_set_messageid(const std::string& value); + std::string* _internal_mutable_messageid(); + public: + + // string fromDeviceID = 2; + void clear_fromdeviceid(); + const std::string& fromdeviceid() const; + void set_fromdeviceid(const std::string& value); + void set_fromdeviceid(std::string&& value); + void set_fromdeviceid(const char* value); + void set_fromdeviceid(const char* value, size_t size); + std::string* mutable_fromdeviceid(); + std::string* release_fromdeviceid(); + void set_allocated_fromdeviceid(std::string* fromdeviceid); + private: + const std::string& _internal_fromdeviceid() const; + void _internal_set_fromdeviceid(const std::string& value); + std::string* _internal_mutable_fromdeviceid(); public: - // string payload = 2; + // string payload = 3; void clear_payload(); const std::string& payload() const; void set_payload(const std::string& value); @@ -1598,7 +2342,7 @@ std::string* _internal_mutable_payload(); public: - // @@protoc_insertion_point(class_scope:tunnelbroker.OutboundMessage) + // @@protoc_insertion_point(class_scope:tunnelbroker.MessageToClientStruct) private: class _Internal; @@ -1606,31 +2350,32 @@ typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField blobhashes_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr todeviceid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr messageid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fromdeviceid_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_tunnelbroker_2eproto; }; // ------------------------------------------------------------------- -class InboundMessage PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.InboundMessage) */ { +class MessagesToDeliver PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.MessagesToDeliver) */ { public: - inline InboundMessage() : InboundMessage(nullptr) {} - virtual ~InboundMessage(); - explicit constexpr InboundMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + inline MessagesToDeliver() : MessagesToDeliver(nullptr) {} + virtual ~MessagesToDeliver(); + explicit constexpr MessagesToDeliver(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - InboundMessage(const InboundMessage& from); - InboundMessage(InboundMessage&& from) noexcept - : InboundMessage() { + MessagesToDeliver(const MessagesToDeliver& from); + MessagesToDeliver(MessagesToDeliver&& from) noexcept + : MessagesToDeliver() { *this = ::std::move(from); } - inline InboundMessage& operator=(const InboundMessage& from) { + inline MessagesToDeliver& operator=(const MessagesToDeliver& from) { CopyFrom(from); return *this; } - inline InboundMessage& operator=(InboundMessage&& from) noexcept { + inline MessagesToDeliver& operator=(MessagesToDeliver&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { @@ -1648,20 +2393,20 @@ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } - static const InboundMessage& default_instance() { + static const MessagesToDeliver& default_instance() { return *internal_default_instance(); } - static inline const InboundMessage* internal_default_instance() { - return reinterpret_cast( - &_InboundMessage_default_instance_); + static inline const MessagesToDeliver* internal_default_instance() { + return reinterpret_cast( + &_MessagesToDeliver_default_instance_); } static constexpr int kIndexInFileMessages = - 8; + 12; - friend void swap(InboundMessage& a, InboundMessage& b) { + friend void swap(MessagesToDeliver& a, MessagesToDeliver& b) { a.Swap(&b); } - inline void Swap(InboundMessage* other) { + inline void Swap(MessagesToDeliver* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); @@ -1669,7 +2414,7 @@ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(InboundMessage* other) { + void UnsafeArenaSwap(MessagesToDeliver* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1677,17 +2422,17 @@ // implements Message ---------------------------------------------- - inline InboundMessage* New() const final { - return CreateMaybeMessage(nullptr); + inline MessagesToDeliver* New() const final { + return CreateMaybeMessage(nullptr); } - InboundMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + MessagesToDeliver* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const InboundMessage& from); - void MergeFrom(const InboundMessage& from); + void CopyFrom(const MessagesToDeliver& from); + void MergeFrom(const MessagesToDeliver& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -1701,13 +2446,13 @@ inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(InboundMessage* other); + void InternalSwap(MessagesToDeliver* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "tunnelbroker.InboundMessage"; + return "tunnelbroker.MessagesToDeliver"; } protected: - explicit InboundMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit MessagesToDeliver(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1726,95 +2471,220 @@ // accessors ------------------------------------------------------- enum : int { - kBlobHashesFieldNumber = 4, - kFromDeviceIDFieldNumber = 1, - kFromConnectionIDFieldNumber = 2, - kPayloadFieldNumber = 3, + kMessagesFieldNumber = 1, }; - // repeated string blobHashes = 4; - int blobhashes_size() const; + // repeated .tunnelbroker.MessageToClientStruct messages = 1; + int messages_size() const; private: - int _internal_blobhashes_size() const; + int _internal_messages_size() const; public: - void clear_blobhashes(); - const std::string& blobhashes(int index) const; - std::string* mutable_blobhashes(int index); - void set_blobhashes(int index, const std::string& value); - void set_blobhashes(int index, std::string&& value); - void set_blobhashes(int index, const char* value); - void set_blobhashes(int index, const char* value, size_t size); - std::string* add_blobhashes(); - void add_blobhashes(const std::string& value); - void add_blobhashes(std::string&& value); - void add_blobhashes(const char* value); - void add_blobhashes(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& blobhashes() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_blobhashes(); + void clear_messages(); + ::tunnelbroker::MessageToClientStruct* mutable_messages(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tunnelbroker::MessageToClientStruct >* + mutable_messages(); private: - const std::string& _internal_blobhashes(int index) const; - std::string* _internal_add_blobhashes(); + const ::tunnelbroker::MessageToClientStruct& _internal_messages(int index) const; + ::tunnelbroker::MessageToClientStruct* _internal_add_messages(); public: + const ::tunnelbroker::MessageToClientStruct& messages(int index) const; + ::tunnelbroker::MessageToClientStruct* add_messages(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tunnelbroker::MessageToClientStruct >& + messages() const; + + // @@protoc_insertion_point(class_scope:tunnelbroker.MessagesToDeliver) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tunnelbroker::MessageToClientStruct > messages_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_tunnelbroker_2eproto; +}; +// ------------------------------------------------------------------- + +class MessageToClient PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.MessageToClient) */ { + public: + inline MessageToClient() : MessageToClient(nullptr) {} + virtual ~MessageToClient(); + explicit constexpr MessageToClient(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MessageToClient(const MessageToClient& from); + MessageToClient(MessageToClient&& from) noexcept + : MessageToClient() { + *this = ::std::move(from); + } + + inline MessageToClient& operator=(const MessageToClient& from) { + CopyFrom(from); + return *this; + } + inline MessageToClient& operator=(MessageToClient&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const MessageToClient& default_instance() { + return *internal_default_instance(); + } + enum DataCase { + kMessagesToDeliver = 1, + kProcessedMessages = 2, + DATA_NOT_SET = 0, + }; + + static inline const MessageToClient* internal_default_instance() { + return reinterpret_cast( + &_MessageToClient_default_instance_); + } + static constexpr int kIndexInFileMessages = + 13; + + friend void swap(MessageToClient& a, MessageToClient& b) { + a.Swap(&b); + } + inline void Swap(MessageToClient* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MessageToClient* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline MessageToClient* New() const final { + return CreateMaybeMessage(nullptr); + } + + MessageToClient* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const MessageToClient& from); + void MergeFrom(const MessageToClient& 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } - // string fromDeviceID = 1; - void clear_fromdeviceid(); - const std::string& fromdeviceid() const; - void set_fromdeviceid(const std::string& value); - void set_fromdeviceid(std::string&& value); - void set_fromdeviceid(const char* value); - void set_fromdeviceid(const char* value, size_t size); - std::string* mutable_fromdeviceid(); - std::string* release_fromdeviceid(); - void set_allocated_fromdeviceid(std::string* fromdeviceid); private: - const std::string& _internal_fromdeviceid() const; - void _internal_set_fromdeviceid(const std::string& value); - std::string* _internal_mutable_fromdeviceid(); + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(MessageToClient* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "tunnelbroker.MessageToClient"; + } + protected: + explicit MessageToClient(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: - // string fromConnectionID = 2; - void clear_fromconnectionid(); - const std::string& fromconnectionid() const; - void set_fromconnectionid(const std::string& value); - void set_fromconnectionid(std::string&& value); - void set_fromconnectionid(const char* value); - void set_fromconnectionid(const char* value, size_t size); - std::string* mutable_fromconnectionid(); - std::string* release_fromconnectionid(); - void set_allocated_fromconnectionid(std::string* fromconnectionid); + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: - const std::string& _internal_fromconnectionid() const; - void _internal_set_fromconnectionid(const std::string& value); - std::string* _internal_mutable_fromconnectionid(); + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages); + } + public: - // string payload = 3; - void clear_payload(); - const std::string& payload() const; - void set_payload(const std::string& value); - void set_payload(std::string&& value); - void set_payload(const char* value); - void set_payload(const char* value, size_t size); - std::string* mutable_payload(); - std::string* release_payload(); - void set_allocated_payload(std::string* payload); + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMessagesToDeliverFieldNumber = 1, + kProcessedMessagesFieldNumber = 2, + }; + // .tunnelbroker.MessagesToDeliver messagesToDeliver = 1; + bool has_messagestodeliver() const; private: - const std::string& _internal_payload() const; - void _internal_set_payload(const std::string& value); - std::string* _internal_mutable_payload(); + bool _internal_has_messagestodeliver() const; + public: + void clear_messagestodeliver(); + const ::tunnelbroker::MessagesToDeliver& messagestodeliver() const; + ::tunnelbroker::MessagesToDeliver* release_messagestodeliver(); + ::tunnelbroker::MessagesToDeliver* mutable_messagestodeliver(); + void set_allocated_messagestodeliver(::tunnelbroker::MessagesToDeliver* messagestodeliver); + private: + const ::tunnelbroker::MessagesToDeliver& _internal_messagestodeliver() const; + ::tunnelbroker::MessagesToDeliver* _internal_mutable_messagestodeliver(); + public: + void unsafe_arena_set_allocated_messagestodeliver( + ::tunnelbroker::MessagesToDeliver* messagestodeliver); + ::tunnelbroker::MessagesToDeliver* unsafe_arena_release_messagestodeliver(); + + // .tunnelbroker.ProcessedMessages processedMessages = 2; + bool has_processedmessages() const; + private: + bool _internal_has_processedmessages() const; + public: + void clear_processedmessages(); + const ::tunnelbroker::ProcessedMessages& processedmessages() const; + ::tunnelbroker::ProcessedMessages* release_processedmessages(); + ::tunnelbroker::ProcessedMessages* mutable_processedmessages(); + void set_allocated_processedmessages(::tunnelbroker::ProcessedMessages* processedmessages); + private: + const ::tunnelbroker::ProcessedMessages& _internal_processedmessages() const; + ::tunnelbroker::ProcessedMessages* _internal_mutable_processedmessages(); public: + void unsafe_arena_set_allocated_processedmessages( + ::tunnelbroker::ProcessedMessages* processedmessages); + ::tunnelbroker::ProcessedMessages* unsafe_arena_release_processedmessages(); - // @@protoc_insertion_point(class_scope:tunnelbroker.InboundMessage) + void clear_data(); + DataCase data_case() const; + // @@protoc_insertion_point(class_scope:tunnelbroker.MessageToClient) private: class _Internal; + void set_has_messagestodeliver(); + void set_has_processedmessages(); + + inline bool has_data() const; + inline void clear_has_data(); template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField blobhashes_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fromdeviceid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fromconnectionid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_; + union DataUnion { + constexpr DataUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::tunnelbroker::MessagesToDeliver* messagestodeliver_; + ::tunnelbroker::ProcessedMessages* processedmessages_; + } data_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + friend struct ::TableStruct_tunnelbroker_2eproto; }; // ------------------------------------------------------------------- @@ -1862,7 +2732,7 @@ &_CheckRequest_default_instance_); } static constexpr int kIndexInFileMessages = - 9; + 14; friend void swap(CheckRequest& a, CheckRequest& b) { a.Swap(&b); @@ -2024,7 +2894,7 @@ &_CheckResponse_default_instance_); } static constexpr int kIndexInFileMessages = - 10; + 15; friend void swap(CheckResponse& a, CheckResponse& b) { a.Swap(&b); @@ -2161,7 +3031,7 @@ &_NewPrimaryRequest_default_instance_); } static constexpr int kIndexInFileMessages = - 11; + 16; friend void swap(NewPrimaryRequest& a, NewPrimaryRequest& b) { a.Swap(&b); @@ -2323,7 +3193,7 @@ &_NewPrimaryResponse_default_instance_); } static constexpr int kIndexInFileMessages = - 12; + 17; friend void swap(NewPrimaryResponse& a, NewPrimaryResponse& b) { a.Swap(&b); @@ -2460,7 +3330,7 @@ &_PongRequest_default_instance_); } static constexpr int kIndexInFileMessages = - 13; + 18; friend void swap(PongRequest& a, PongRequest& b) { a.Swap(&b); @@ -3683,85 +4553,224 @@ blobhashes_.Add()->assign(value); // @@protoc_insertion_point(field_add:tunnelbroker.GetResponse.blobHashes) } -inline void GetResponse::add_blobhashes(std::string&& value) { - blobhashes_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:tunnelbroker.GetResponse.blobHashes) +inline void GetResponse::add_blobhashes(std::string&& value) { + blobhashes_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:tunnelbroker.GetResponse.blobHashes) +} +inline void GetResponse::add_blobhashes(const char* value) { + GOOGLE_DCHECK(value != nullptr); + blobhashes_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:tunnelbroker.GetResponse.blobHashes) +} +inline void GetResponse::add_blobhashes(const char* value, size_t size) { + blobhashes_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:tunnelbroker.GetResponse.blobHashes) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +GetResponse::blobhashes() const { + // @@protoc_insertion_point(field_list:tunnelbroker.GetResponse.blobHashes) + return blobhashes_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +GetResponse::mutable_blobhashes() { + // @@protoc_insertion_point(field_mutable_list:tunnelbroker.GetResponse.blobHashes) + return &blobhashes_; +} + +// ------------------------------------------------------------------- + +// ProcessedMessages + +// repeated string messageID = 1; +inline int ProcessedMessages::_internal_messageid_size() const { + return messageid_.size(); +} +inline int ProcessedMessages::messageid_size() const { + return _internal_messageid_size(); +} +inline void ProcessedMessages::clear_messageid() { + messageid_.Clear(); +} +inline std::string* ProcessedMessages::add_messageid() { + // @@protoc_insertion_point(field_add_mutable:tunnelbroker.ProcessedMessages.messageID) + return _internal_add_messageid(); +} +inline const std::string& ProcessedMessages::_internal_messageid(int index) const { + return messageid_.Get(index); +} +inline const std::string& ProcessedMessages::messageid(int index) const { + // @@protoc_insertion_point(field_get:tunnelbroker.ProcessedMessages.messageID) + return _internal_messageid(index); +} +inline std::string* ProcessedMessages::mutable_messageid(int index) { + // @@protoc_insertion_point(field_mutable:tunnelbroker.ProcessedMessages.messageID) + return messageid_.Mutable(index); +} +inline void ProcessedMessages::set_messageid(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:tunnelbroker.ProcessedMessages.messageID) + messageid_.Mutable(index)->assign(value); +} +inline void ProcessedMessages::set_messageid(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:tunnelbroker.ProcessedMessages.messageID) + messageid_.Mutable(index)->assign(std::move(value)); +} +inline void ProcessedMessages::set_messageid(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + messageid_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:tunnelbroker.ProcessedMessages.messageID) +} +inline void ProcessedMessages::set_messageid(int index, const char* value, size_t size) { + messageid_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:tunnelbroker.ProcessedMessages.messageID) +} +inline std::string* ProcessedMessages::_internal_add_messageid() { + return messageid_.Add(); +} +inline void ProcessedMessages::add_messageid(const std::string& value) { + messageid_.Add()->assign(value); + // @@protoc_insertion_point(field_add:tunnelbroker.ProcessedMessages.messageID) +} +inline void ProcessedMessages::add_messageid(std::string&& value) { + messageid_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:tunnelbroker.ProcessedMessages.messageID) } -inline void GetResponse::add_blobhashes(const char* value) { +inline void ProcessedMessages::add_messageid(const char* value) { GOOGLE_DCHECK(value != nullptr); - blobhashes_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:tunnelbroker.GetResponse.blobHashes) + messageid_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:tunnelbroker.ProcessedMessages.messageID) } -inline void GetResponse::add_blobhashes(const char* value, size_t size) { - blobhashes_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:tunnelbroker.GetResponse.blobHashes) +inline void ProcessedMessages::add_messageid(const char* value, size_t size) { + messageid_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:tunnelbroker.ProcessedMessages.messageID) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -GetResponse::blobhashes() const { - // @@protoc_insertion_point(field_list:tunnelbroker.GetResponse.blobHashes) - return blobhashes_; +ProcessedMessages::messageid() const { + // @@protoc_insertion_point(field_list:tunnelbroker.ProcessedMessages.messageID) + return messageid_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -GetResponse::mutable_blobhashes() { - // @@protoc_insertion_point(field_mutable_list:tunnelbroker.GetResponse.blobHashes) - return &blobhashes_; +ProcessedMessages::mutable_messageid() { + // @@protoc_insertion_point(field_mutable_list:tunnelbroker.ProcessedMessages.messageID) + return &messageid_; } // ------------------------------------------------------------------- -// OutboundMessage +// MessageToTunnelbrokerStruct + +// string messageID = 1; +inline void MessageToTunnelbrokerStruct::clear_messageid() { + messageid_.ClearToEmpty(); +} +inline const std::string& MessageToTunnelbrokerStruct::messageid() const { + // @@protoc_insertion_point(field_get:tunnelbroker.MessageToTunnelbrokerStruct.messageID) + return _internal_messageid(); +} +inline void MessageToTunnelbrokerStruct::set_messageid(const std::string& value) { + _internal_set_messageid(value); + // @@protoc_insertion_point(field_set:tunnelbroker.MessageToTunnelbrokerStruct.messageID) +} +inline std::string* MessageToTunnelbrokerStruct::mutable_messageid() { + // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToTunnelbrokerStruct.messageID) + return _internal_mutable_messageid(); +} +inline const std::string& MessageToTunnelbrokerStruct::_internal_messageid() const { + return messageid_.Get(); +} +inline void MessageToTunnelbrokerStruct::_internal_set_messageid(const std::string& value) { + + messageid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline void MessageToTunnelbrokerStruct::set_messageid(std::string&& value) { + + messageid_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.MessageToTunnelbrokerStruct.messageID) +} +inline void MessageToTunnelbrokerStruct::set_messageid(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + messageid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:tunnelbroker.MessageToTunnelbrokerStruct.messageID) +} +inline void MessageToTunnelbrokerStruct::set_messageid(const char* value, + size_t size) { + + messageid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:tunnelbroker.MessageToTunnelbrokerStruct.messageID) +} +inline std::string* MessageToTunnelbrokerStruct::_internal_mutable_messageid() { + + return messageid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* MessageToTunnelbrokerStruct::release_messageid() { + // @@protoc_insertion_point(field_release:tunnelbroker.MessageToTunnelbrokerStruct.messageID) + return messageid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void MessageToTunnelbrokerStruct::set_allocated_messageid(std::string* messageid) { + if (messageid != nullptr) { + + } else { + + } + messageid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), messageid, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:tunnelbroker.MessageToTunnelbrokerStruct.messageID) +} -// string toDeviceID = 1; -inline void OutboundMessage::clear_todeviceid() { +// string toDeviceID = 2; +inline void MessageToTunnelbrokerStruct::clear_todeviceid() { todeviceid_.ClearToEmpty(); } -inline const std::string& OutboundMessage::todeviceid() const { - // @@protoc_insertion_point(field_get:tunnelbroker.OutboundMessage.toDeviceID) +inline const std::string& MessageToTunnelbrokerStruct::todeviceid() const { + // @@protoc_insertion_point(field_get:tunnelbroker.MessageToTunnelbrokerStruct.toDeviceID) return _internal_todeviceid(); } -inline void OutboundMessage::set_todeviceid(const std::string& value) { +inline void MessageToTunnelbrokerStruct::set_todeviceid(const std::string& value) { _internal_set_todeviceid(value); - // @@protoc_insertion_point(field_set:tunnelbroker.OutboundMessage.toDeviceID) + // @@protoc_insertion_point(field_set:tunnelbroker.MessageToTunnelbrokerStruct.toDeviceID) } -inline std::string* OutboundMessage::mutable_todeviceid() { - // @@protoc_insertion_point(field_mutable:tunnelbroker.OutboundMessage.toDeviceID) +inline std::string* MessageToTunnelbrokerStruct::mutable_todeviceid() { + // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToTunnelbrokerStruct.toDeviceID) return _internal_mutable_todeviceid(); } -inline const std::string& OutboundMessage::_internal_todeviceid() const { +inline const std::string& MessageToTunnelbrokerStruct::_internal_todeviceid() const { return todeviceid_.Get(); } -inline void OutboundMessage::_internal_set_todeviceid(const std::string& value) { +inline void MessageToTunnelbrokerStruct::_internal_set_todeviceid(const std::string& value) { todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } -inline void OutboundMessage::set_todeviceid(std::string&& value) { +inline void MessageToTunnelbrokerStruct::set_todeviceid(std::string&& value) { todeviceid_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); - // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.OutboundMessage.toDeviceID) + // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.MessageToTunnelbrokerStruct.toDeviceID) } -inline void OutboundMessage::set_todeviceid(const char* value) { +inline void MessageToTunnelbrokerStruct::set_todeviceid(const char* value) { GOOGLE_DCHECK(value != nullptr); todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); - // @@protoc_insertion_point(field_set_char:tunnelbroker.OutboundMessage.toDeviceID) + // @@protoc_insertion_point(field_set_char:tunnelbroker.MessageToTunnelbrokerStruct.toDeviceID) } -inline void OutboundMessage::set_todeviceid(const char* value, +inline void MessageToTunnelbrokerStruct::set_todeviceid(const char* value, size_t size) { todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); - // @@protoc_insertion_point(field_set_pointer:tunnelbroker.OutboundMessage.toDeviceID) + // @@protoc_insertion_point(field_set_pointer:tunnelbroker.MessageToTunnelbrokerStruct.toDeviceID) } -inline std::string* OutboundMessage::_internal_mutable_todeviceid() { +inline std::string* MessageToTunnelbrokerStruct::_internal_mutable_todeviceid() { return todeviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } -inline std::string* OutboundMessage::release_todeviceid() { - // @@protoc_insertion_point(field_release:tunnelbroker.OutboundMessage.toDeviceID) +inline std::string* MessageToTunnelbrokerStruct::release_todeviceid() { + // @@protoc_insertion_point(field_release:tunnelbroker.MessageToTunnelbrokerStruct.toDeviceID) return todeviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } -inline void OutboundMessage::set_allocated_todeviceid(std::string* todeviceid) { +inline void MessageToTunnelbrokerStruct::set_allocated_todeviceid(std::string* todeviceid) { if (todeviceid != nullptr) { } else { @@ -3769,60 +4778,60 @@ } todeviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), todeviceid, GetArena()); - // @@protoc_insertion_point(field_set_allocated:tunnelbroker.OutboundMessage.toDeviceID) + // @@protoc_insertion_point(field_set_allocated:tunnelbroker.MessageToTunnelbrokerStruct.toDeviceID) } -// string payload = 2; -inline void OutboundMessage::clear_payload() { +// string payload = 3; +inline void MessageToTunnelbrokerStruct::clear_payload() { payload_.ClearToEmpty(); } -inline const std::string& OutboundMessage::payload() const { - // @@protoc_insertion_point(field_get:tunnelbroker.OutboundMessage.payload) +inline const std::string& MessageToTunnelbrokerStruct::payload() const { + // @@protoc_insertion_point(field_get:tunnelbroker.MessageToTunnelbrokerStruct.payload) return _internal_payload(); } -inline void OutboundMessage::set_payload(const std::string& value) { +inline void MessageToTunnelbrokerStruct::set_payload(const std::string& value) { _internal_set_payload(value); - // @@protoc_insertion_point(field_set:tunnelbroker.OutboundMessage.payload) + // @@protoc_insertion_point(field_set:tunnelbroker.MessageToTunnelbrokerStruct.payload) } -inline std::string* OutboundMessage::mutable_payload() { - // @@protoc_insertion_point(field_mutable:tunnelbroker.OutboundMessage.payload) +inline std::string* MessageToTunnelbrokerStruct::mutable_payload() { + // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToTunnelbrokerStruct.payload) return _internal_mutable_payload(); } -inline const std::string& OutboundMessage::_internal_payload() const { +inline const std::string& MessageToTunnelbrokerStruct::_internal_payload() const { return payload_.Get(); } -inline void OutboundMessage::_internal_set_payload(const std::string& value) { +inline void MessageToTunnelbrokerStruct::_internal_set_payload(const std::string& value) { payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } -inline void OutboundMessage::set_payload(std::string&& value) { +inline void MessageToTunnelbrokerStruct::set_payload(std::string&& value) { payload_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); - // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.OutboundMessage.payload) + // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.MessageToTunnelbrokerStruct.payload) } -inline void OutboundMessage::set_payload(const char* value) { +inline void MessageToTunnelbrokerStruct::set_payload(const char* value) { GOOGLE_DCHECK(value != nullptr); payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); - // @@protoc_insertion_point(field_set_char:tunnelbroker.OutboundMessage.payload) + // @@protoc_insertion_point(field_set_char:tunnelbroker.MessageToTunnelbrokerStruct.payload) } -inline void OutboundMessage::set_payload(const char* value, +inline void MessageToTunnelbrokerStruct::set_payload(const char* value, size_t size) { payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); - // @@protoc_insertion_point(field_set_pointer:tunnelbroker.OutboundMessage.payload) + // @@protoc_insertion_point(field_set_pointer:tunnelbroker.MessageToTunnelbrokerStruct.payload) } -inline std::string* OutboundMessage::_internal_mutable_payload() { +inline std::string* MessageToTunnelbrokerStruct::_internal_mutable_payload() { return payload_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } -inline std::string* OutboundMessage::release_payload() { - // @@protoc_insertion_point(field_release:tunnelbroker.OutboundMessage.payload) +inline std::string* MessageToTunnelbrokerStruct::release_payload() { + // @@protoc_insertion_point(field_release:tunnelbroker.MessageToTunnelbrokerStruct.payload) return payload_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } -inline void OutboundMessage::set_allocated_payload(std::string* payload) { +inline void MessageToTunnelbrokerStruct::set_allocated_payload(std::string* payload) { if (payload != nullptr) { } else { @@ -3830,260 +4839,523 @@ } payload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), payload, GetArena()); - // @@protoc_insertion_point(field_set_allocated:tunnelbroker.OutboundMessage.payload) + // @@protoc_insertion_point(field_set_allocated:tunnelbroker.MessageToTunnelbrokerStruct.payload) } -// repeated string blobHashes = 3; -inline int OutboundMessage::_internal_blobhashes_size() const { +// repeated string blobHashes = 4; +inline int MessageToTunnelbrokerStruct::_internal_blobhashes_size() const { return blobhashes_.size(); } -inline int OutboundMessage::blobhashes_size() const { +inline int MessageToTunnelbrokerStruct::blobhashes_size() const { return _internal_blobhashes_size(); } -inline void OutboundMessage::clear_blobhashes() { +inline void MessageToTunnelbrokerStruct::clear_blobhashes() { blobhashes_.Clear(); } -inline std::string* OutboundMessage::add_blobhashes() { - // @@protoc_insertion_point(field_add_mutable:tunnelbroker.OutboundMessage.blobHashes) +inline std::string* MessageToTunnelbrokerStruct::add_blobhashes() { + // @@protoc_insertion_point(field_add_mutable:tunnelbroker.MessageToTunnelbrokerStruct.blobHashes) return _internal_add_blobhashes(); } -inline const std::string& OutboundMessage::_internal_blobhashes(int index) const { +inline const std::string& MessageToTunnelbrokerStruct::_internal_blobhashes(int index) const { return blobhashes_.Get(index); } -inline const std::string& OutboundMessage::blobhashes(int index) const { - // @@protoc_insertion_point(field_get:tunnelbroker.OutboundMessage.blobHashes) +inline const std::string& MessageToTunnelbrokerStruct::blobhashes(int index) const { + // @@protoc_insertion_point(field_get:tunnelbroker.MessageToTunnelbrokerStruct.blobHashes) return _internal_blobhashes(index); } -inline std::string* OutboundMessage::mutable_blobhashes(int index) { - // @@protoc_insertion_point(field_mutable:tunnelbroker.OutboundMessage.blobHashes) +inline std::string* MessageToTunnelbrokerStruct::mutable_blobhashes(int index) { + // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToTunnelbrokerStruct.blobHashes) return blobhashes_.Mutable(index); } -inline void OutboundMessage::set_blobhashes(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:tunnelbroker.OutboundMessage.blobHashes) +inline void MessageToTunnelbrokerStruct::set_blobhashes(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:tunnelbroker.MessageToTunnelbrokerStruct.blobHashes) blobhashes_.Mutable(index)->assign(value); } -inline void OutboundMessage::set_blobhashes(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:tunnelbroker.OutboundMessage.blobHashes) +inline void MessageToTunnelbrokerStruct::set_blobhashes(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:tunnelbroker.MessageToTunnelbrokerStruct.blobHashes) blobhashes_.Mutable(index)->assign(std::move(value)); } -inline void OutboundMessage::set_blobhashes(int index, const char* value) { +inline void MessageToTunnelbrokerStruct::set_blobhashes(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); blobhashes_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:tunnelbroker.OutboundMessage.blobHashes) + // @@protoc_insertion_point(field_set_char:tunnelbroker.MessageToTunnelbrokerStruct.blobHashes) } -inline void OutboundMessage::set_blobhashes(int index, const char* value, size_t size) { +inline void MessageToTunnelbrokerStruct::set_blobhashes(int index, const char* value, size_t size) { blobhashes_.Mutable(index)->assign( reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:tunnelbroker.OutboundMessage.blobHashes) + // @@protoc_insertion_point(field_set_pointer:tunnelbroker.MessageToTunnelbrokerStruct.blobHashes) } -inline std::string* OutboundMessage::_internal_add_blobhashes() { +inline std::string* MessageToTunnelbrokerStruct::_internal_add_blobhashes() { return blobhashes_.Add(); } -inline void OutboundMessage::add_blobhashes(const std::string& value) { +inline void MessageToTunnelbrokerStruct::add_blobhashes(const std::string& value) { blobhashes_.Add()->assign(value); - // @@protoc_insertion_point(field_add:tunnelbroker.OutboundMessage.blobHashes) + // @@protoc_insertion_point(field_add:tunnelbroker.MessageToTunnelbrokerStruct.blobHashes) } -inline void OutboundMessage::add_blobhashes(std::string&& value) { +inline void MessageToTunnelbrokerStruct::add_blobhashes(std::string&& value) { blobhashes_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:tunnelbroker.OutboundMessage.blobHashes) + // @@protoc_insertion_point(field_add:tunnelbroker.MessageToTunnelbrokerStruct.blobHashes) } -inline void OutboundMessage::add_blobhashes(const char* value) { +inline void MessageToTunnelbrokerStruct::add_blobhashes(const char* value) { GOOGLE_DCHECK(value != nullptr); blobhashes_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:tunnelbroker.OutboundMessage.blobHashes) + // @@protoc_insertion_point(field_add_char:tunnelbroker.MessageToTunnelbrokerStruct.blobHashes) } -inline void OutboundMessage::add_blobhashes(const char* value, size_t size) { +inline void MessageToTunnelbrokerStruct::add_blobhashes(const char* value, size_t size) { blobhashes_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:tunnelbroker.OutboundMessage.blobHashes) + // @@protoc_insertion_point(field_add_pointer:tunnelbroker.MessageToTunnelbrokerStruct.blobHashes) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -OutboundMessage::blobhashes() const { - // @@protoc_insertion_point(field_list:tunnelbroker.OutboundMessage.blobHashes) +MessageToTunnelbrokerStruct::blobhashes() const { + // @@protoc_insertion_point(field_list:tunnelbroker.MessageToTunnelbrokerStruct.blobHashes) return blobhashes_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -OutboundMessage::mutable_blobhashes() { - // @@protoc_insertion_point(field_mutable_list:tunnelbroker.OutboundMessage.blobHashes) +MessageToTunnelbrokerStruct::mutable_blobhashes() { + // @@protoc_insertion_point(field_mutable_list:tunnelbroker.MessageToTunnelbrokerStruct.blobHashes) return &blobhashes_; } // ------------------------------------------------------------------- -// InboundMessage +// MessagesToSend -// string fromDeviceID = 1; -inline void InboundMessage::clear_fromdeviceid() { - fromdeviceid_.ClearToEmpty(); +// repeated .tunnelbroker.MessageToTunnelbrokerStruct messages = 1; +inline int MessagesToSend::_internal_messages_size() const { + return messages_.size(); } -inline const std::string& InboundMessage::fromdeviceid() const { - // @@protoc_insertion_point(field_get:tunnelbroker.InboundMessage.fromDeviceID) - return _internal_fromdeviceid(); +inline int MessagesToSend::messages_size() const { + return _internal_messages_size(); } -inline void InboundMessage::set_fromdeviceid(const std::string& value) { - _internal_set_fromdeviceid(value); - // @@protoc_insertion_point(field_set:tunnelbroker.InboundMessage.fromDeviceID) +inline void MessagesToSend::clear_messages() { + messages_.Clear(); } -inline std::string* InboundMessage::mutable_fromdeviceid() { - // @@protoc_insertion_point(field_mutable:tunnelbroker.InboundMessage.fromDeviceID) - return _internal_mutable_fromdeviceid(); +inline ::tunnelbroker::MessageToTunnelbrokerStruct* MessagesToSend::mutable_messages(int index) { + // @@protoc_insertion_point(field_mutable:tunnelbroker.MessagesToSend.messages) + return messages_.Mutable(index); } -inline const std::string& InboundMessage::_internal_fromdeviceid() const { - return fromdeviceid_.Get(); +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tunnelbroker::MessageToTunnelbrokerStruct >* +MessagesToSend::mutable_messages() { + // @@protoc_insertion_point(field_mutable_list:tunnelbroker.MessagesToSend.messages) + return &messages_; +} +inline const ::tunnelbroker::MessageToTunnelbrokerStruct& MessagesToSend::_internal_messages(int index) const { + return messages_.Get(index); +} +inline const ::tunnelbroker::MessageToTunnelbrokerStruct& MessagesToSend::messages(int index) const { + // @@protoc_insertion_point(field_get:tunnelbroker.MessagesToSend.messages) + return _internal_messages(index); +} +inline ::tunnelbroker::MessageToTunnelbrokerStruct* MessagesToSend::_internal_add_messages() { + return messages_.Add(); +} +inline ::tunnelbroker::MessageToTunnelbrokerStruct* MessagesToSend::add_messages() { + // @@protoc_insertion_point(field_add:tunnelbroker.MessagesToSend.messages) + return _internal_add_messages(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tunnelbroker::MessageToTunnelbrokerStruct >& +MessagesToSend::messages() const { + // @@protoc_insertion_point(field_list:tunnelbroker.MessagesToSend.messages) + return messages_; +} + +// ------------------------------------------------------------------- + +// MessageToTunnelbroker + +// string sessionID = 1; +inline void MessageToTunnelbroker::clear_sessionid() { + sessionid_.ClearToEmpty(); } -inline void InboundMessage::_internal_set_fromdeviceid(const std::string& value) { +inline const std::string& MessageToTunnelbroker::sessionid() const { + // @@protoc_insertion_point(field_get:tunnelbroker.MessageToTunnelbroker.sessionID) + return _internal_sessionid(); +} +inline void MessageToTunnelbroker::set_sessionid(const std::string& value) { + _internal_set_sessionid(value); + // @@protoc_insertion_point(field_set:tunnelbroker.MessageToTunnelbroker.sessionID) +} +inline std::string* MessageToTunnelbroker::mutable_sessionid() { + // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToTunnelbroker.sessionID) + return _internal_mutable_sessionid(); +} +inline const std::string& MessageToTunnelbroker::_internal_sessionid() const { + return sessionid_.Get(); +} +inline void MessageToTunnelbroker::_internal_set_sessionid(const std::string& value) { - fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } -inline void InboundMessage::set_fromdeviceid(std::string&& value) { +inline void MessageToTunnelbroker::set_sessionid(std::string&& value) { - fromdeviceid_.Set( + sessionid_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); - // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.InboundMessage.fromDeviceID) + // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.MessageToTunnelbroker.sessionID) } -inline void InboundMessage::set_fromdeviceid(const char* value) { +inline void MessageToTunnelbroker::set_sessionid(const char* value) { GOOGLE_DCHECK(value != nullptr); - fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); - // @@protoc_insertion_point(field_set_char:tunnelbroker.InboundMessage.fromDeviceID) + sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:tunnelbroker.MessageToTunnelbroker.sessionID) } -inline void InboundMessage::set_fromdeviceid(const char* value, +inline void MessageToTunnelbroker::set_sessionid(const char* value, size_t size) { - fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); - // @@protoc_insertion_point(field_set_pointer:tunnelbroker.InboundMessage.fromDeviceID) + // @@protoc_insertion_point(field_set_pointer:tunnelbroker.MessageToTunnelbroker.sessionID) } -inline std::string* InboundMessage::_internal_mutable_fromdeviceid() { +inline std::string* MessageToTunnelbroker::_internal_mutable_sessionid() { - return fromdeviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return sessionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } -inline std::string* InboundMessage::release_fromdeviceid() { - // @@protoc_insertion_point(field_release:tunnelbroker.InboundMessage.fromDeviceID) - return fromdeviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +inline std::string* MessageToTunnelbroker::release_sessionid() { + // @@protoc_insertion_point(field_release:tunnelbroker.MessageToTunnelbroker.sessionID) + return sessionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } -inline void InboundMessage::set_allocated_fromdeviceid(std::string* fromdeviceid) { - if (fromdeviceid != nullptr) { +inline void MessageToTunnelbroker::set_allocated_sessionid(std::string* sessionid) { + if (sessionid != nullptr) { } else { } - fromdeviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fromdeviceid, + sessionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sessionid, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:tunnelbroker.MessageToTunnelbroker.sessionID) +} + +// .tunnelbroker.MessagesToSend messagesToSend = 2; +inline bool MessageToTunnelbroker::_internal_has_messagestosend() const { + return data_case() == kMessagesToSend; +} +inline bool MessageToTunnelbroker::has_messagestosend() const { + return _internal_has_messagestosend(); +} +inline void MessageToTunnelbroker::set_has_messagestosend() { + _oneof_case_[0] = kMessagesToSend; +} +inline void MessageToTunnelbroker::clear_messagestosend() { + if (_internal_has_messagestosend()) { + if (GetArena() == nullptr) { + delete data_.messagestosend_; + } + clear_has_data(); + } +} +inline ::tunnelbroker::MessagesToSend* MessageToTunnelbroker::release_messagestosend() { + // @@protoc_insertion_point(field_release:tunnelbroker.MessageToTunnelbroker.messagesToSend) + if (_internal_has_messagestosend()) { + clear_has_data(); + ::tunnelbroker::MessagesToSend* temp = data_.messagestosend_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + data_.messagestosend_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::tunnelbroker::MessagesToSend& MessageToTunnelbroker::_internal_messagestosend() const { + return _internal_has_messagestosend() + ? *data_.messagestosend_ + : reinterpret_cast< ::tunnelbroker::MessagesToSend&>(::tunnelbroker::_MessagesToSend_default_instance_); +} +inline const ::tunnelbroker::MessagesToSend& MessageToTunnelbroker::messagestosend() const { + // @@protoc_insertion_point(field_get:tunnelbroker.MessageToTunnelbroker.messagesToSend) + return _internal_messagestosend(); +} +inline ::tunnelbroker::MessagesToSend* MessageToTunnelbroker::unsafe_arena_release_messagestosend() { + // @@protoc_insertion_point(field_unsafe_arena_release:tunnelbroker.MessageToTunnelbroker.messagesToSend) + if (_internal_has_messagestosend()) { + clear_has_data(); + ::tunnelbroker::MessagesToSend* temp = data_.messagestosend_; + data_.messagestosend_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void MessageToTunnelbroker::unsafe_arena_set_allocated_messagestosend(::tunnelbroker::MessagesToSend* messagestosend) { + clear_data(); + if (messagestosend) { + set_has_messagestosend(); + data_.messagestosend_ = messagestosend; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tunnelbroker.MessageToTunnelbroker.messagesToSend) +} +inline ::tunnelbroker::MessagesToSend* MessageToTunnelbroker::_internal_mutable_messagestosend() { + if (!_internal_has_messagestosend()) { + clear_data(); + set_has_messagestosend(); + data_.messagestosend_ = CreateMaybeMessage< ::tunnelbroker::MessagesToSend >(GetArena()); + } + return data_.messagestosend_; +} +inline ::tunnelbroker::MessagesToSend* MessageToTunnelbroker::mutable_messagestosend() { + // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToTunnelbroker.messagesToSend) + return _internal_mutable_messagestosend(); +} + +// .tunnelbroker.ProcessedMessages processedMessages = 3; +inline bool MessageToTunnelbroker::_internal_has_processedmessages() const { + return data_case() == kProcessedMessages; +} +inline bool MessageToTunnelbroker::has_processedmessages() const { + return _internal_has_processedmessages(); +} +inline void MessageToTunnelbroker::set_has_processedmessages() { + _oneof_case_[0] = kProcessedMessages; +} +inline void MessageToTunnelbroker::clear_processedmessages() { + if (_internal_has_processedmessages()) { + if (GetArena() == nullptr) { + delete data_.processedmessages_; + } + clear_has_data(); + } +} +inline ::tunnelbroker::ProcessedMessages* MessageToTunnelbroker::release_processedmessages() { + // @@protoc_insertion_point(field_release:tunnelbroker.MessageToTunnelbroker.processedMessages) + if (_internal_has_processedmessages()) { + clear_has_data(); + ::tunnelbroker::ProcessedMessages* temp = data_.processedmessages_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + data_.processedmessages_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::tunnelbroker::ProcessedMessages& MessageToTunnelbroker::_internal_processedmessages() const { + return _internal_has_processedmessages() + ? *data_.processedmessages_ + : reinterpret_cast< ::tunnelbroker::ProcessedMessages&>(::tunnelbroker::_ProcessedMessages_default_instance_); +} +inline const ::tunnelbroker::ProcessedMessages& MessageToTunnelbroker::processedmessages() const { + // @@protoc_insertion_point(field_get:tunnelbroker.MessageToTunnelbroker.processedMessages) + return _internal_processedmessages(); +} +inline ::tunnelbroker::ProcessedMessages* MessageToTunnelbroker::unsafe_arena_release_processedmessages() { + // @@protoc_insertion_point(field_unsafe_arena_release:tunnelbroker.MessageToTunnelbroker.processedMessages) + if (_internal_has_processedmessages()) { + clear_has_data(); + ::tunnelbroker::ProcessedMessages* temp = data_.processedmessages_; + data_.processedmessages_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void MessageToTunnelbroker::unsafe_arena_set_allocated_processedmessages(::tunnelbroker::ProcessedMessages* processedmessages) { + clear_data(); + if (processedmessages) { + set_has_processedmessages(); + data_.processedmessages_ = processedmessages; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tunnelbroker.MessageToTunnelbroker.processedMessages) +} +inline ::tunnelbroker::ProcessedMessages* MessageToTunnelbroker::_internal_mutable_processedmessages() { + if (!_internal_has_processedmessages()) { + clear_data(); + set_has_processedmessages(); + data_.processedmessages_ = CreateMaybeMessage< ::tunnelbroker::ProcessedMessages >(GetArena()); + } + return data_.processedmessages_; +} +inline ::tunnelbroker::ProcessedMessages* MessageToTunnelbroker::mutable_processedmessages() { + // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToTunnelbroker.processedMessages) + return _internal_mutable_processedmessages(); +} + +inline bool MessageToTunnelbroker::has_data() const { + return data_case() != DATA_NOT_SET; +} +inline void MessageToTunnelbroker::clear_has_data() { + _oneof_case_[0] = DATA_NOT_SET; +} +inline MessageToTunnelbroker::DataCase MessageToTunnelbroker::data_case() const { + return MessageToTunnelbroker::DataCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// MessageToClientStruct + +// string messageID = 1; +inline void MessageToClientStruct::clear_messageid() { + messageid_.ClearToEmpty(); +} +inline const std::string& MessageToClientStruct::messageid() const { + // @@protoc_insertion_point(field_get:tunnelbroker.MessageToClientStruct.messageID) + return _internal_messageid(); +} +inline void MessageToClientStruct::set_messageid(const std::string& value) { + _internal_set_messageid(value); + // @@protoc_insertion_point(field_set:tunnelbroker.MessageToClientStruct.messageID) +} +inline std::string* MessageToClientStruct::mutable_messageid() { + // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToClientStruct.messageID) + return _internal_mutable_messageid(); +} +inline const std::string& MessageToClientStruct::_internal_messageid() const { + return messageid_.Get(); +} +inline void MessageToClientStruct::_internal_set_messageid(const std::string& value) { + + messageid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline void MessageToClientStruct::set_messageid(std::string&& value) { + + messageid_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.MessageToClientStruct.messageID) +} +inline void MessageToClientStruct::set_messageid(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + messageid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:tunnelbroker.MessageToClientStruct.messageID) +} +inline void MessageToClientStruct::set_messageid(const char* value, + size_t size) { + + messageid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:tunnelbroker.MessageToClientStruct.messageID) +} +inline std::string* MessageToClientStruct::_internal_mutable_messageid() { + + return messageid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* MessageToClientStruct::release_messageid() { + // @@protoc_insertion_point(field_release:tunnelbroker.MessageToClientStruct.messageID) + return messageid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void MessageToClientStruct::set_allocated_messageid(std::string* messageid) { + if (messageid != nullptr) { + + } else { + + } + messageid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), messageid, GetArena()); - // @@protoc_insertion_point(field_set_allocated:tunnelbroker.InboundMessage.fromDeviceID) + // @@protoc_insertion_point(field_set_allocated:tunnelbroker.MessageToClientStruct.messageID) } -// string fromConnectionID = 2; -inline void InboundMessage::clear_fromconnectionid() { - fromconnectionid_.ClearToEmpty(); +// string fromDeviceID = 2; +inline void MessageToClientStruct::clear_fromdeviceid() { + fromdeviceid_.ClearToEmpty(); } -inline const std::string& InboundMessage::fromconnectionid() const { - // @@protoc_insertion_point(field_get:tunnelbroker.InboundMessage.fromConnectionID) - return _internal_fromconnectionid(); +inline const std::string& MessageToClientStruct::fromdeviceid() const { + // @@protoc_insertion_point(field_get:tunnelbroker.MessageToClientStruct.fromDeviceID) + return _internal_fromdeviceid(); } -inline void InboundMessage::set_fromconnectionid(const std::string& value) { - _internal_set_fromconnectionid(value); - // @@protoc_insertion_point(field_set:tunnelbroker.InboundMessage.fromConnectionID) +inline void MessageToClientStruct::set_fromdeviceid(const std::string& value) { + _internal_set_fromdeviceid(value); + // @@protoc_insertion_point(field_set:tunnelbroker.MessageToClientStruct.fromDeviceID) } -inline std::string* InboundMessage::mutable_fromconnectionid() { - // @@protoc_insertion_point(field_mutable:tunnelbroker.InboundMessage.fromConnectionID) - return _internal_mutable_fromconnectionid(); +inline std::string* MessageToClientStruct::mutable_fromdeviceid() { + // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToClientStruct.fromDeviceID) + return _internal_mutable_fromdeviceid(); } -inline const std::string& InboundMessage::_internal_fromconnectionid() const { - return fromconnectionid_.Get(); +inline const std::string& MessageToClientStruct::_internal_fromdeviceid() const { + return fromdeviceid_.Get(); } -inline void InboundMessage::_internal_set_fromconnectionid(const std::string& value) { +inline void MessageToClientStruct::_internal_set_fromdeviceid(const std::string& value) { - fromconnectionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } -inline void InboundMessage::set_fromconnectionid(std::string&& value) { +inline void MessageToClientStruct::set_fromdeviceid(std::string&& value) { - fromconnectionid_.Set( + fromdeviceid_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); - // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.InboundMessage.fromConnectionID) + // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.MessageToClientStruct.fromDeviceID) } -inline void InboundMessage::set_fromconnectionid(const char* value) { +inline void MessageToClientStruct::set_fromdeviceid(const char* value) { GOOGLE_DCHECK(value != nullptr); - fromconnectionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); - // @@protoc_insertion_point(field_set_char:tunnelbroker.InboundMessage.fromConnectionID) + fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:tunnelbroker.MessageToClientStruct.fromDeviceID) } -inline void InboundMessage::set_fromconnectionid(const char* value, +inline void MessageToClientStruct::set_fromdeviceid(const char* value, size_t size) { - fromconnectionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); - // @@protoc_insertion_point(field_set_pointer:tunnelbroker.InboundMessage.fromConnectionID) + // @@protoc_insertion_point(field_set_pointer:tunnelbroker.MessageToClientStruct.fromDeviceID) } -inline std::string* InboundMessage::_internal_mutable_fromconnectionid() { +inline std::string* MessageToClientStruct::_internal_mutable_fromdeviceid() { - return fromconnectionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return fromdeviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } -inline std::string* InboundMessage::release_fromconnectionid() { - // @@protoc_insertion_point(field_release:tunnelbroker.InboundMessage.fromConnectionID) - return fromconnectionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +inline std::string* MessageToClientStruct::release_fromdeviceid() { + // @@protoc_insertion_point(field_release:tunnelbroker.MessageToClientStruct.fromDeviceID) + return fromdeviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } -inline void InboundMessage::set_allocated_fromconnectionid(std::string* fromconnectionid) { - if (fromconnectionid != nullptr) { +inline void MessageToClientStruct::set_allocated_fromdeviceid(std::string* fromdeviceid) { + if (fromdeviceid != nullptr) { } else { } - fromconnectionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fromconnectionid, + fromdeviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fromdeviceid, GetArena()); - // @@protoc_insertion_point(field_set_allocated:tunnelbroker.InboundMessage.fromConnectionID) + // @@protoc_insertion_point(field_set_allocated:tunnelbroker.MessageToClientStruct.fromDeviceID) } // string payload = 3; -inline void InboundMessage::clear_payload() { +inline void MessageToClientStruct::clear_payload() { payload_.ClearToEmpty(); } -inline const std::string& InboundMessage::payload() const { - // @@protoc_insertion_point(field_get:tunnelbroker.InboundMessage.payload) +inline const std::string& MessageToClientStruct::payload() const { + // @@protoc_insertion_point(field_get:tunnelbroker.MessageToClientStruct.payload) return _internal_payload(); } -inline void InboundMessage::set_payload(const std::string& value) { +inline void MessageToClientStruct::set_payload(const std::string& value) { _internal_set_payload(value); - // @@protoc_insertion_point(field_set:tunnelbroker.InboundMessage.payload) + // @@protoc_insertion_point(field_set:tunnelbroker.MessageToClientStruct.payload) } -inline std::string* InboundMessage::mutable_payload() { - // @@protoc_insertion_point(field_mutable:tunnelbroker.InboundMessage.payload) +inline std::string* MessageToClientStruct::mutable_payload() { + // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToClientStruct.payload) return _internal_mutable_payload(); } -inline const std::string& InboundMessage::_internal_payload() const { +inline const std::string& MessageToClientStruct::_internal_payload() const { return payload_.Get(); } -inline void InboundMessage::_internal_set_payload(const std::string& value) { +inline void MessageToClientStruct::_internal_set_payload(const std::string& value) { payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } -inline void InboundMessage::set_payload(std::string&& value) { +inline void MessageToClientStruct::set_payload(std::string&& value) { payload_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); - // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.InboundMessage.payload) + // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.MessageToClientStruct.payload) } -inline void InboundMessage::set_payload(const char* value) { +inline void MessageToClientStruct::set_payload(const char* value) { GOOGLE_DCHECK(value != nullptr); payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); - // @@protoc_insertion_point(field_set_char:tunnelbroker.InboundMessage.payload) + // @@protoc_insertion_point(field_set_char:tunnelbroker.MessageToClientStruct.payload) } -inline void InboundMessage::set_payload(const char* value, +inline void MessageToClientStruct::set_payload(const char* value, size_t size) { payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); - // @@protoc_insertion_point(field_set_pointer:tunnelbroker.InboundMessage.payload) + // @@protoc_insertion_point(field_set_pointer:tunnelbroker.MessageToClientStruct.payload) } -inline std::string* InboundMessage::_internal_mutable_payload() { +inline std::string* MessageToClientStruct::_internal_mutable_payload() { return payload_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } -inline std::string* InboundMessage::release_payload() { - // @@protoc_insertion_point(field_release:tunnelbroker.InboundMessage.payload) +inline std::string* MessageToClientStruct::release_payload() { + // @@protoc_insertion_point(field_release:tunnelbroker.MessageToClientStruct.payload) return payload_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } -inline void InboundMessage::set_allocated_payload(std::string* payload) { +inline void MessageToClientStruct::set_allocated_payload(std::string* payload) { if (payload != nullptr) { } else { @@ -4091,85 +5363,287 @@ } payload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), payload, GetArena()); - // @@protoc_insertion_point(field_set_allocated:tunnelbroker.InboundMessage.payload) + // @@protoc_insertion_point(field_set_allocated:tunnelbroker.MessageToClientStruct.payload) } // repeated string blobHashes = 4; -inline int InboundMessage::_internal_blobhashes_size() const { +inline int MessageToClientStruct::_internal_blobhashes_size() const { return blobhashes_.size(); } -inline int InboundMessage::blobhashes_size() const { +inline int MessageToClientStruct::blobhashes_size() const { return _internal_blobhashes_size(); } -inline void InboundMessage::clear_blobhashes() { +inline void MessageToClientStruct::clear_blobhashes() { blobhashes_.Clear(); } -inline std::string* InboundMessage::add_blobhashes() { - // @@protoc_insertion_point(field_add_mutable:tunnelbroker.InboundMessage.blobHashes) +inline std::string* MessageToClientStruct::add_blobhashes() { + // @@protoc_insertion_point(field_add_mutable:tunnelbroker.MessageToClientStruct.blobHashes) return _internal_add_blobhashes(); } -inline const std::string& InboundMessage::_internal_blobhashes(int index) const { +inline const std::string& MessageToClientStruct::_internal_blobhashes(int index) const { return blobhashes_.Get(index); } -inline const std::string& InboundMessage::blobhashes(int index) const { - // @@protoc_insertion_point(field_get:tunnelbroker.InboundMessage.blobHashes) +inline const std::string& MessageToClientStruct::blobhashes(int index) const { + // @@protoc_insertion_point(field_get:tunnelbroker.MessageToClientStruct.blobHashes) return _internal_blobhashes(index); } -inline std::string* InboundMessage::mutable_blobhashes(int index) { - // @@protoc_insertion_point(field_mutable:tunnelbroker.InboundMessage.blobHashes) +inline std::string* MessageToClientStruct::mutable_blobhashes(int index) { + // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToClientStruct.blobHashes) return blobhashes_.Mutable(index); } -inline void InboundMessage::set_blobhashes(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:tunnelbroker.InboundMessage.blobHashes) +inline void MessageToClientStruct::set_blobhashes(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:tunnelbroker.MessageToClientStruct.blobHashes) blobhashes_.Mutable(index)->assign(value); } -inline void InboundMessage::set_blobhashes(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:tunnelbroker.InboundMessage.blobHashes) +inline void MessageToClientStruct::set_blobhashes(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:tunnelbroker.MessageToClientStruct.blobHashes) blobhashes_.Mutable(index)->assign(std::move(value)); } -inline void InboundMessage::set_blobhashes(int index, const char* value) { +inline void MessageToClientStruct::set_blobhashes(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); blobhashes_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:tunnelbroker.InboundMessage.blobHashes) + // @@protoc_insertion_point(field_set_char:tunnelbroker.MessageToClientStruct.blobHashes) } -inline void InboundMessage::set_blobhashes(int index, const char* value, size_t size) { +inline void MessageToClientStruct::set_blobhashes(int index, const char* value, size_t size) { blobhashes_.Mutable(index)->assign( reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:tunnelbroker.InboundMessage.blobHashes) + // @@protoc_insertion_point(field_set_pointer:tunnelbroker.MessageToClientStruct.blobHashes) } -inline std::string* InboundMessage::_internal_add_blobhashes() { +inline std::string* MessageToClientStruct::_internal_add_blobhashes() { return blobhashes_.Add(); } -inline void InboundMessage::add_blobhashes(const std::string& value) { +inline void MessageToClientStruct::add_blobhashes(const std::string& value) { blobhashes_.Add()->assign(value); - // @@protoc_insertion_point(field_add:tunnelbroker.InboundMessage.blobHashes) + // @@protoc_insertion_point(field_add:tunnelbroker.MessageToClientStruct.blobHashes) } -inline void InboundMessage::add_blobhashes(std::string&& value) { +inline void MessageToClientStruct::add_blobhashes(std::string&& value) { blobhashes_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:tunnelbroker.InboundMessage.blobHashes) + // @@protoc_insertion_point(field_add:tunnelbroker.MessageToClientStruct.blobHashes) } -inline void InboundMessage::add_blobhashes(const char* value) { +inline void MessageToClientStruct::add_blobhashes(const char* value) { GOOGLE_DCHECK(value != nullptr); blobhashes_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:tunnelbroker.InboundMessage.blobHashes) + // @@protoc_insertion_point(field_add_char:tunnelbroker.MessageToClientStruct.blobHashes) } -inline void InboundMessage::add_blobhashes(const char* value, size_t size) { +inline void MessageToClientStruct::add_blobhashes(const char* value, size_t size) { blobhashes_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:tunnelbroker.InboundMessage.blobHashes) + // @@protoc_insertion_point(field_add_pointer:tunnelbroker.MessageToClientStruct.blobHashes) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -InboundMessage::blobhashes() const { - // @@protoc_insertion_point(field_list:tunnelbroker.InboundMessage.blobHashes) +MessageToClientStruct::blobhashes() const { + // @@protoc_insertion_point(field_list:tunnelbroker.MessageToClientStruct.blobHashes) return blobhashes_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -InboundMessage::mutable_blobhashes() { - // @@protoc_insertion_point(field_mutable_list:tunnelbroker.InboundMessage.blobHashes) +MessageToClientStruct::mutable_blobhashes() { + // @@protoc_insertion_point(field_mutable_list:tunnelbroker.MessageToClientStruct.blobHashes) return &blobhashes_; } // ------------------------------------------------------------------- +// MessagesToDeliver + +// repeated .tunnelbroker.MessageToClientStruct messages = 1; +inline int MessagesToDeliver::_internal_messages_size() const { + return messages_.size(); +} +inline int MessagesToDeliver::messages_size() const { + return _internal_messages_size(); +} +inline void MessagesToDeliver::clear_messages() { + messages_.Clear(); +} +inline ::tunnelbroker::MessageToClientStruct* MessagesToDeliver::mutable_messages(int index) { + // @@protoc_insertion_point(field_mutable:tunnelbroker.MessagesToDeliver.messages) + return messages_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tunnelbroker::MessageToClientStruct >* +MessagesToDeliver::mutable_messages() { + // @@protoc_insertion_point(field_mutable_list:tunnelbroker.MessagesToDeliver.messages) + return &messages_; +} +inline const ::tunnelbroker::MessageToClientStruct& MessagesToDeliver::_internal_messages(int index) const { + return messages_.Get(index); +} +inline const ::tunnelbroker::MessageToClientStruct& MessagesToDeliver::messages(int index) const { + // @@protoc_insertion_point(field_get:tunnelbroker.MessagesToDeliver.messages) + return _internal_messages(index); +} +inline ::tunnelbroker::MessageToClientStruct* MessagesToDeliver::_internal_add_messages() { + return messages_.Add(); +} +inline ::tunnelbroker::MessageToClientStruct* MessagesToDeliver::add_messages() { + // @@protoc_insertion_point(field_add:tunnelbroker.MessagesToDeliver.messages) + return _internal_add_messages(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tunnelbroker::MessageToClientStruct >& +MessagesToDeliver::messages() const { + // @@protoc_insertion_point(field_list:tunnelbroker.MessagesToDeliver.messages) + return messages_; +} + +// ------------------------------------------------------------------- + +// MessageToClient + +// .tunnelbroker.MessagesToDeliver messagesToDeliver = 1; +inline bool MessageToClient::_internal_has_messagestodeliver() const { + return data_case() == kMessagesToDeliver; +} +inline bool MessageToClient::has_messagestodeliver() const { + return _internal_has_messagestodeliver(); +} +inline void MessageToClient::set_has_messagestodeliver() { + _oneof_case_[0] = kMessagesToDeliver; +} +inline void MessageToClient::clear_messagestodeliver() { + if (_internal_has_messagestodeliver()) { + if (GetArena() == nullptr) { + delete data_.messagestodeliver_; + } + clear_has_data(); + } +} +inline ::tunnelbroker::MessagesToDeliver* MessageToClient::release_messagestodeliver() { + // @@protoc_insertion_point(field_release:tunnelbroker.MessageToClient.messagesToDeliver) + if (_internal_has_messagestodeliver()) { + clear_has_data(); + ::tunnelbroker::MessagesToDeliver* temp = data_.messagestodeliver_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + data_.messagestodeliver_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::tunnelbroker::MessagesToDeliver& MessageToClient::_internal_messagestodeliver() const { + return _internal_has_messagestodeliver() + ? *data_.messagestodeliver_ + : reinterpret_cast< ::tunnelbroker::MessagesToDeliver&>(::tunnelbroker::_MessagesToDeliver_default_instance_); +} +inline const ::tunnelbroker::MessagesToDeliver& MessageToClient::messagestodeliver() const { + // @@protoc_insertion_point(field_get:tunnelbroker.MessageToClient.messagesToDeliver) + return _internal_messagestodeliver(); +} +inline ::tunnelbroker::MessagesToDeliver* MessageToClient::unsafe_arena_release_messagestodeliver() { + // @@protoc_insertion_point(field_unsafe_arena_release:tunnelbroker.MessageToClient.messagesToDeliver) + if (_internal_has_messagestodeliver()) { + clear_has_data(); + ::tunnelbroker::MessagesToDeliver* temp = data_.messagestodeliver_; + data_.messagestodeliver_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void MessageToClient::unsafe_arena_set_allocated_messagestodeliver(::tunnelbroker::MessagesToDeliver* messagestodeliver) { + clear_data(); + if (messagestodeliver) { + set_has_messagestodeliver(); + data_.messagestodeliver_ = messagestodeliver; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tunnelbroker.MessageToClient.messagesToDeliver) +} +inline ::tunnelbroker::MessagesToDeliver* MessageToClient::_internal_mutable_messagestodeliver() { + if (!_internal_has_messagestodeliver()) { + clear_data(); + set_has_messagestodeliver(); + data_.messagestodeliver_ = CreateMaybeMessage< ::tunnelbroker::MessagesToDeliver >(GetArena()); + } + return data_.messagestodeliver_; +} +inline ::tunnelbroker::MessagesToDeliver* MessageToClient::mutable_messagestodeliver() { + // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToClient.messagesToDeliver) + return _internal_mutable_messagestodeliver(); +} + +// .tunnelbroker.ProcessedMessages processedMessages = 2; +inline bool MessageToClient::_internal_has_processedmessages() const { + return data_case() == kProcessedMessages; +} +inline bool MessageToClient::has_processedmessages() const { + return _internal_has_processedmessages(); +} +inline void MessageToClient::set_has_processedmessages() { + _oneof_case_[0] = kProcessedMessages; +} +inline void MessageToClient::clear_processedmessages() { + if (_internal_has_processedmessages()) { + if (GetArena() == nullptr) { + delete data_.processedmessages_; + } + clear_has_data(); + } +} +inline ::tunnelbroker::ProcessedMessages* MessageToClient::release_processedmessages() { + // @@protoc_insertion_point(field_release:tunnelbroker.MessageToClient.processedMessages) + if (_internal_has_processedmessages()) { + clear_has_data(); + ::tunnelbroker::ProcessedMessages* temp = data_.processedmessages_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + data_.processedmessages_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::tunnelbroker::ProcessedMessages& MessageToClient::_internal_processedmessages() const { + return _internal_has_processedmessages() + ? *data_.processedmessages_ + : reinterpret_cast< ::tunnelbroker::ProcessedMessages&>(::tunnelbroker::_ProcessedMessages_default_instance_); +} +inline const ::tunnelbroker::ProcessedMessages& MessageToClient::processedmessages() const { + // @@protoc_insertion_point(field_get:tunnelbroker.MessageToClient.processedMessages) + return _internal_processedmessages(); +} +inline ::tunnelbroker::ProcessedMessages* MessageToClient::unsafe_arena_release_processedmessages() { + // @@protoc_insertion_point(field_unsafe_arena_release:tunnelbroker.MessageToClient.processedMessages) + if (_internal_has_processedmessages()) { + clear_has_data(); + ::tunnelbroker::ProcessedMessages* temp = data_.processedmessages_; + data_.processedmessages_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void MessageToClient::unsafe_arena_set_allocated_processedmessages(::tunnelbroker::ProcessedMessages* processedmessages) { + clear_data(); + if (processedmessages) { + set_has_processedmessages(); + data_.processedmessages_ = processedmessages; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tunnelbroker.MessageToClient.processedMessages) +} +inline ::tunnelbroker::ProcessedMessages* MessageToClient::_internal_mutable_processedmessages() { + if (!_internal_has_processedmessages()) { + clear_data(); + set_has_processedmessages(); + data_.processedmessages_ = CreateMaybeMessage< ::tunnelbroker::ProcessedMessages >(GetArena()); + } + return data_.processedmessages_; +} +inline ::tunnelbroker::ProcessedMessages* MessageToClient::mutable_processedmessages() { + // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToClient.processedMessages) + return _internal_mutable_processedmessages(); +} + +inline bool MessageToClient::has_data() const { + return data_case() != DATA_NOT_SET; +} +inline void MessageToClient::clear_has_data() { + _oneof_case_[0] = DATA_NOT_SET; +} +inline MessageToClient::DataCase MessageToClient::data_case() const { + return MessageToClient::DataCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + // CheckRequest // string userId = 1; @@ -4623,6 +6097,16 @@ // ------------------------------------------------------------------- +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + // @@protoc_insertion_point(namespace_scope) diff --git a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.cc b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.cc --- a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.cc +++ b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.cc @@ -113,35 +113,97 @@ }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT GetResponseDefaultTypeInternal _GetResponse_default_instance_; -constexpr OutboundMessage::OutboundMessage( +constexpr ProcessedMessages::ProcessedMessages( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : messageid_(){} +struct ProcessedMessagesDefaultTypeInternal { + constexpr ProcessedMessagesDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ProcessedMessagesDefaultTypeInternal() {} + union { + ProcessedMessages _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ProcessedMessagesDefaultTypeInternal _ProcessedMessages_default_instance_; +constexpr MessageToTunnelbrokerStruct::MessageToTunnelbrokerStruct( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : blobhashes_() + , messageid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , todeviceid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , payload_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} -struct OutboundMessageDefaultTypeInternal { - constexpr OutboundMessageDefaultTypeInternal() +struct MessageToTunnelbrokerStructDefaultTypeInternal { + constexpr MessageToTunnelbrokerStructDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~MessageToTunnelbrokerStructDefaultTypeInternal() {} + union { + MessageToTunnelbrokerStruct _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MessageToTunnelbrokerStructDefaultTypeInternal _MessageToTunnelbrokerStruct_default_instance_; +constexpr MessagesToSend::MessagesToSend( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : messages_(){} +struct MessagesToSendDefaultTypeInternal { + constexpr MessagesToSendDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~MessagesToSendDefaultTypeInternal() {} + union { + MessagesToSend _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MessagesToSendDefaultTypeInternal _MessagesToSend_default_instance_; +constexpr MessageToTunnelbroker::MessageToTunnelbroker( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : sessionid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , _oneof_case_{}{} +struct MessageToTunnelbrokerDefaultTypeInternal { + constexpr MessageToTunnelbrokerDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~OutboundMessageDefaultTypeInternal() {} + ~MessageToTunnelbrokerDefaultTypeInternal() {} union { - OutboundMessage _instance; + MessageToTunnelbroker _instance; }; }; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OutboundMessageDefaultTypeInternal _OutboundMessage_default_instance_; -constexpr InboundMessage::InboundMessage( +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MessageToTunnelbrokerDefaultTypeInternal _MessageToTunnelbroker_default_instance_; +constexpr MessageToClientStruct::MessageToClientStruct( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : blobhashes_() + , messageid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , fromdeviceid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , fromconnectionid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , payload_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} -struct InboundMessageDefaultTypeInternal { - constexpr InboundMessageDefaultTypeInternal() +struct MessageToClientStructDefaultTypeInternal { + constexpr MessageToClientStructDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~MessageToClientStructDefaultTypeInternal() {} + union { + MessageToClientStruct _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MessageToClientStructDefaultTypeInternal _MessageToClientStruct_default_instance_; +constexpr MessagesToDeliver::MessagesToDeliver( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : messages_(){} +struct MessagesToDeliverDefaultTypeInternal { + constexpr MessagesToDeliverDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~MessagesToDeliverDefaultTypeInternal() {} + union { + MessagesToDeliver _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MessagesToDeliverDefaultTypeInternal _MessagesToDeliver_default_instance_; +constexpr MessageToClient::MessageToClient( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : _oneof_case_{}{} +struct MessageToClientDefaultTypeInternal { + constexpr MessageToClientDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~InboundMessageDefaultTypeInternal() {} + ~MessageToClientDefaultTypeInternal() {} union { - InboundMessage _instance; + MessageToClient _instance; }; }; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT InboundMessageDefaultTypeInternal _InboundMessage_default_instance_; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MessageToClientDefaultTypeInternal _MessageToClient_default_instance_; constexpr CheckRequest::CheckRequest( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) @@ -207,7 +269,7 @@ }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PongRequestDefaultTypeInternal _PongRequest_default_instance_; } // namespace tunnelbroker -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_tunnelbroker_2eproto[14]; +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_tunnelbroker_2eproto[19]; static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_tunnelbroker_2eproto[2]; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_tunnelbroker_2eproto = nullptr; @@ -273,22 +335,58 @@ PROTOBUF_FIELD_OFFSET(::tunnelbroker::GetResponse, payload_), PROTOBUF_FIELD_OFFSET(::tunnelbroker::GetResponse, blobhashes_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::tunnelbroker::OutboundMessage, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::tunnelbroker::ProcessedMessages, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::tunnelbroker::ProcessedMessages, messageid_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToTunnelbrokerStruct, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToTunnelbrokerStruct, messageid_), + PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToTunnelbrokerStruct, todeviceid_), + PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToTunnelbrokerStruct, payload_), + PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToTunnelbrokerStruct, blobhashes_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessagesToSend, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessagesToSend, messages_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToTunnelbroker, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToTunnelbroker, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToTunnelbroker, sessionid_), + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToTunnelbroker, data_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToClientStruct, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::tunnelbroker::OutboundMessage, todeviceid_), - PROTOBUF_FIELD_OFFSET(::tunnelbroker::OutboundMessage, payload_), - PROTOBUF_FIELD_OFFSET(::tunnelbroker::OutboundMessage, blobhashes_), + PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToClientStruct, messageid_), + PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToClientStruct, fromdeviceid_), + PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToClientStruct, payload_), + PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToClientStruct, blobhashes_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::tunnelbroker::InboundMessage, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessagesToDeliver, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::tunnelbroker::InboundMessage, fromdeviceid_), - PROTOBUF_FIELD_OFFSET(::tunnelbroker::InboundMessage, fromconnectionid_), - PROTOBUF_FIELD_OFFSET(::tunnelbroker::InboundMessage, payload_), - PROTOBUF_FIELD_OFFSET(::tunnelbroker::InboundMessage, blobhashes_), + PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessagesToDeliver, messages_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToClient, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToClient, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToClient, data_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::CheckRequest, _internal_metadata_), ~0u, // no _extensions_ @@ -331,13 +429,18 @@ { 37, -1, sizeof(::tunnelbroker::SendRequest)}, { 46, -1, sizeof(::tunnelbroker::GetRequest)}, { 52, -1, sizeof(::tunnelbroker::GetResponse)}, - { 60, -1, sizeof(::tunnelbroker::OutboundMessage)}, - { 68, -1, sizeof(::tunnelbroker::InboundMessage)}, - { 77, -1, sizeof(::tunnelbroker::CheckRequest)}, - { 84, -1, sizeof(::tunnelbroker::CheckResponse)}, - { 90, -1, sizeof(::tunnelbroker::NewPrimaryRequest)}, - { 97, -1, sizeof(::tunnelbroker::NewPrimaryResponse)}, - { 103, -1, sizeof(::tunnelbroker::PongRequest)}, + { 60, -1, sizeof(::tunnelbroker::ProcessedMessages)}, + { 66, -1, sizeof(::tunnelbroker::MessageToTunnelbrokerStruct)}, + { 75, -1, sizeof(::tunnelbroker::MessagesToSend)}, + { 81, -1, sizeof(::tunnelbroker::MessageToTunnelbroker)}, + { 90, -1, sizeof(::tunnelbroker::MessageToClientStruct)}, + { 99, -1, sizeof(::tunnelbroker::MessagesToDeliver)}, + { 105, -1, sizeof(::tunnelbroker::MessageToClient)}, + { 113, -1, sizeof(::tunnelbroker::CheckRequest)}, + { 120, -1, sizeof(::tunnelbroker::CheckResponse)}, + { 126, -1, sizeof(::tunnelbroker::NewPrimaryRequest)}, + { 133, -1, sizeof(::tunnelbroker::NewPrimaryResponse)}, + { 139, -1, sizeof(::tunnelbroker::PongRequest)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { @@ -348,8 +451,13 @@ reinterpret_cast(&::tunnelbroker::_SendRequest_default_instance_), reinterpret_cast(&::tunnelbroker::_GetRequest_default_instance_), reinterpret_cast(&::tunnelbroker::_GetResponse_default_instance_), - reinterpret_cast(&::tunnelbroker::_OutboundMessage_default_instance_), - reinterpret_cast(&::tunnelbroker::_InboundMessage_default_instance_), + reinterpret_cast(&::tunnelbroker::_ProcessedMessages_default_instance_), + reinterpret_cast(&::tunnelbroker::_MessageToTunnelbrokerStruct_default_instance_), + reinterpret_cast(&::tunnelbroker::_MessagesToSend_default_instance_), + reinterpret_cast(&::tunnelbroker::_MessageToTunnelbroker_default_instance_), + reinterpret_cast(&::tunnelbroker::_MessageToClientStruct_default_instance_), + reinterpret_cast(&::tunnelbroker::_MessagesToDeliver_default_instance_), + reinterpret_cast(&::tunnelbroker::_MessageToClient_default_instance_), reinterpret_cast(&::tunnelbroker::_CheckRequest_default_instance_), reinterpret_cast(&::tunnelbroker::_CheckResponse_default_instance_), reinterpret_cast(&::tunnelbroker::_NewPrimaryRequest_default_instance_), @@ -374,46 +482,60 @@ "D\030\002 \001(\t\022\017\n\007payload\030\003 \001(\014\022\022\n\nblobHashes\030\004" " \003(\t\"\037\n\nGetRequest\022\021\n\tsessionID\030\001 \001(\t\"H\n" "\013GetResponse\022\024\n\014fromDeviceID\030\001 \001(\t\022\017\n\007pa" - "yload\030\002 \001(\014\022\022\n\nblobHashes\030\003 \003(\t\"J\n\017Outbo" - "undMessage\022\022\n\ntoDeviceID\030\001 \001(\t\022\017\n\007payloa" - "d\030\002 \001(\t\022\022\n\nblobHashes\030\003 \003(\t\"e\n\016InboundMe" - "ssage\022\024\n\014fromDeviceID\030\001 \001(\t\022\030\n\020fromConne" - "ctionID\030\002 \001(\t\022\017\n\007payload\030\003 \001(\t\022\022\n\nblobHa" - "shes\030\004 \003(\t\"3\n\014CheckRequest\022\016\n\006userId\030\001 \001" - "(\t\022\023\n\013deviceToken\030\002 \001(\t\"K\n\rCheckResponse" - "\022:\n\021checkResponseType\030\001 \001(\0162\037.tunnelbrok" - "er.CheckResponseType\"8\n\021NewPrimaryReques" - "t\022\016\n\006userId\030\001 \001(\t\022\023\n\013deviceToken\030\002 \001(\t\"%" - "\n\022NewPrimaryResponse\022\017\n\007success\030\001 \001(\010\"2\n" - "\013PongRequest\022\016\n\006userId\030\001 \001(\t\022\023\n\013deviceTo" - "ken\030\002 \001(\t*n\n\021CheckResponseType\022\030\n\024PRIMAR" - "Y_DOESNT_EXIST\020\000\022\022\n\016PRIMARY_ONLINE\020\001\022\023\n\017" - "PRIMARY_OFFLINE\020\002\022\026\n\022CURRENT_IS_PRIMARY\020" - "\0032\224\005\n\023TunnelbrokerService\022W\n\032CheckIfPrim" - "aryDeviceOnline\022\032.tunnelbroker.CheckRequ" - "est\032\033.tunnelbroker.CheckResponse\"\000\022]\n\026Be" - "comeNewPrimaryDevice\022\037.tunnelbroker.NewP" - "rimaryRequest\032 .tunnelbroker.NewPrimaryR" - "esponse\"\000\022\?\n\010SendPong\022\031.tunnelbroker.Pon" - "gRequest\032\026.google.protobuf.Empty\"\000\022c\n\020Se" - "ssionSignature\022%.tunnelbroker.SessionSig" - "natureRequest\032&.tunnelbroker.SessionSign" - "atureResponse\"\000\022Q\n\nNewSession\022\037.tunnelbr" - "oker.NewSessionRequest\032 .tunnelbroker.Ne" - "wSessionResponse\"\000\022;\n\004Send\022\031.tunnelbroke" - "r.SendRequest\032\026.google.protobuf.Empty\"\000\022" - ">\n\003Get\022\030.tunnelbroker.GetRequest\032\031.tunne" - "lbroker.GetResponse\"\0000\001\022O\n\nOpenStream\022\035." - "tunnelbroker.OutboundMessage\032\034.tunnelbro" - "ker.InboundMessage\"\000(\0010\001b\006proto3" + "yload\030\002 \001(\014\022\022\n\nblobHashes\030\003 \003(\t\"&\n\021Proce" + "ssedMessages\022\021\n\tmessageID\030\001 \003(\t\"i\n\033Messa" + "geToTunnelbrokerStruct\022\021\n\tmessageID\030\001 \001(" + "\t\022\022\n\ntoDeviceID\030\002 \001(\t\022\017\n\007payload\030\003 \001(\t\022\022" + "\n\nblobHashes\030\004 \003(\t\"M\n\016MessagesToSend\022;\n\010" + "messages\030\001 \003(\0132).tunnelbroker.MessageToT" + "unnelbrokerStruct\"\250\001\n\025MessageToTunnelbro" + "ker\022\021\n\tsessionID\030\001 \001(\t\0226\n\016messagesToSend" + "\030\002 \001(\0132\034.tunnelbroker.MessagesToSendH\000\022<" + "\n\021processedMessages\030\003 \001(\0132\037.tunnelbroker" + ".ProcessedMessagesH\000B\006\n\004data\"e\n\025MessageT" + "oClientStruct\022\021\n\tmessageID\030\001 \001(\t\022\024\n\014from" + "DeviceID\030\002 \001(\t\022\017\n\007payload\030\003 \001(\t\022\022\n\nblobH" + "ashes\030\004 \003(\t\"J\n\021MessagesToDeliver\0225\n\010mess" + "ages\030\001 \003(\0132#.tunnelbroker.MessageToClien" + "tStruct\"\225\001\n\017MessageToClient\022<\n\021messagesT" + "oDeliver\030\001 \001(\0132\037.tunnelbroker.MessagesTo" + "DeliverH\000\022<\n\021processedMessages\030\002 \001(\0132\037.t" + "unnelbroker.ProcessedMessagesH\000B\006\n\004data\"" + "3\n\014CheckRequest\022\016\n\006userId\030\001 \001(\t\022\023\n\013devic" + "eToken\030\002 \001(\t\"K\n\rCheckResponse\022:\n\021checkRe" + "sponseType\030\001 \001(\0162\037.tunnelbroker.CheckRes" + "ponseType\"8\n\021NewPrimaryRequest\022\016\n\006userId" + "\030\001 \001(\t\022\023\n\013deviceToken\030\002 \001(\t\"%\n\022NewPrimar" + "yResponse\022\017\n\007success\030\001 \001(\010\"2\n\013PongReques" + "t\022\016\n\006userId\030\001 \001(\t\022\023\n\013deviceToken\030\002 \001(\t*n" + "\n\021CheckResponseType\022\030\n\024PRIMARY_DOESNT_EX" + "IST\020\000\022\022\n\016PRIMARY_ONLINE\020\001\022\023\n\017PRIMARY_OFF" + "LINE\020\002\022\026\n\022CURRENT_IS_PRIMARY\020\0032\237\005\n\023Tunne" + "lbrokerService\022W\n\032CheckIfPrimaryDeviceOn" + "line\022\032.tunnelbroker.CheckRequest\032\033.tunne" + "lbroker.CheckResponse\"\000\022]\n\026BecomeNewPrim" + "aryDevice\022\037.tunnelbroker.NewPrimaryReque" + "st\032 .tunnelbroker.NewPrimaryResponse\"\000\022\?" + "\n\010SendPong\022\031.tunnelbroker.PongRequest\032\026." + "google.protobuf.Empty\"\000\022c\n\020SessionSignat" + "ure\022%.tunnelbroker.SessionSignatureReque" + "st\032&.tunnelbroker.SessionSignatureRespon" + "se\"\000\022Q\n\nNewSession\022\037.tunnelbroker.NewSes" + "sionRequest\032 .tunnelbroker.NewSessionRes" + "ponse\"\000\022;\n\004Send\022\031.tunnelbroker.SendReque" + "st\032\026.google.protobuf.Empty\"\000\022>\n\003Get\022\030.tu" + "nnelbroker.GetRequest\032\031.tunnelbroker.Get" + "Response\"\0000\001\022Z\n\016MessagesStream\022#.tunnelb" + "roker.MessageToTunnelbroker\032\035.tunnelbrok" + "er.MessageToClient\"\000(\0010\001b\006proto3" ; static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_tunnelbroker_2eproto_deps[1] = { &::descriptor_table_google_2fprotobuf_2fempty_2eproto, }; static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_tunnelbroker_2eproto_once; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tunnelbroker_2eproto = { - false, false, 1912, descriptor_table_protodef_tunnelbroker_2eproto, "tunnelbroker.proto", - &descriptor_table_tunnelbroker_2eproto_once, descriptor_table_tunnelbroker_2eproto_deps, 1, 14, + false, false, 2472, descriptor_table_protodef_tunnelbroker_2eproto, "tunnelbroker.proto", + &descriptor_table_tunnelbroker_2eproto_once, descriptor_table_tunnelbroker_2eproto_deps, 1, 19, schemas, file_default_instances, TableStruct_tunnelbroker_2eproto::offsets, file_level_metadata_tunnelbroker_2eproto, file_level_enum_descriptors_tunnelbroker_2eproto, file_level_service_descriptors_tunnelbroker_2eproto, }; @@ -2277,110 +2399,76 @@ // =================================================================== -class OutboundMessage::_Internal { +class ProcessedMessages::_Internal { public: }; -OutboundMessage::OutboundMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena) +ProcessedMessages::ProcessedMessages(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), - blobhashes_(arena) { + messageid_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:tunnelbroker.OutboundMessage) + // @@protoc_insertion_point(arena_constructor:tunnelbroker.ProcessedMessages) } -OutboundMessage::OutboundMessage(const OutboundMessage& from) +ProcessedMessages::ProcessedMessages(const ProcessedMessages& from) : ::PROTOBUF_NAMESPACE_ID::Message(), - blobhashes_(from.blobhashes_) { + messageid_(from.messageid_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - todeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_todeviceid().empty()) { - todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_todeviceid(), - GetArena()); - } - payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_payload().empty()) { - payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_payload(), - GetArena()); - } - // @@protoc_insertion_point(copy_constructor:tunnelbroker.OutboundMessage) + // @@protoc_insertion_point(copy_constructor:tunnelbroker.ProcessedMessages) } -void OutboundMessage::SharedCtor() { -todeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +void ProcessedMessages::SharedCtor() { } -OutboundMessage::~OutboundMessage() { - // @@protoc_insertion_point(destructor:tunnelbroker.OutboundMessage) +ProcessedMessages::~ProcessedMessages() { + // @@protoc_insertion_point(destructor:tunnelbroker.ProcessedMessages) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void OutboundMessage::SharedDtor() { +void ProcessedMessages::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - todeviceid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - payload_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -void OutboundMessage::ArenaDtor(void* object) { - OutboundMessage* _this = reinterpret_cast< OutboundMessage* >(object); +void ProcessedMessages::ArenaDtor(void* object) { + ProcessedMessages* _this = reinterpret_cast< ProcessedMessages* >(object); (void)_this; } -void OutboundMessage::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +void ProcessedMessages::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } -void OutboundMessage::SetCachedSize(int size) const { +void ProcessedMessages::SetCachedSize(int size) const { _cached_size_.Set(size); } -void OutboundMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:tunnelbroker.OutboundMessage) +void ProcessedMessages::Clear() { +// @@protoc_insertion_point(message_clear_start:tunnelbroker.ProcessedMessages) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - blobhashes_.Clear(); - todeviceid_.ClearToEmpty(); - payload_.ClearToEmpty(); + messageid_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const char* OutboundMessage::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* ProcessedMessages::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // string toDeviceID = 1; + // repeated string messageID = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - auto str = _internal_mutable_todeviceid(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.OutboundMessage.toDeviceID")); - CHK_(ptr); - } else goto handle_unusual; - continue; - // string payload = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - auto str = _internal_mutable_payload(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.OutboundMessage.payload")); - CHK_(ptr); - } else goto handle_unusual; - continue; - // repeated string blobHashes = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr -= 1; do { ptr += 1; - auto str = _internal_add_blobhashes(); + auto str = _internal_add_messageid(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.OutboundMessage.blobHashes")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.ProcessedMessages.messageID")); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; default: { @@ -2405,78 +2493,44 @@ #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* OutboundMessage::_InternalSerialize( +::PROTOBUF_NAMESPACE_ID::uint8* ProcessedMessages::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.OutboundMessage) + // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.ProcessedMessages) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string toDeviceID = 1; - if (this->todeviceid().size() > 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_todeviceid().data(), static_cast(this->_internal_todeviceid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "tunnelbroker.OutboundMessage.toDeviceID"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_todeviceid(), target); - } - - // string payload = 2; - if (this->payload().size() > 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_payload().data(), static_cast(this->_internal_payload().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "tunnelbroker.OutboundMessage.payload"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_payload(), target); - } - - // repeated string blobHashes = 3; - for (int i = 0, n = this->_internal_blobhashes_size(); i < n; i++) { - const auto& s = this->_internal_blobhashes(i); + // repeated string messageID = 1; + for (int i = 0, n = this->_internal_messageid_size(); i < n; i++) { + const auto& s = this->_internal_messageid(i); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "tunnelbroker.OutboundMessage.blobHashes"); - target = stream->WriteString(3, s, target); + "tunnelbroker.ProcessedMessages.messageID"); + target = stream->WriteString(1, s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.OutboundMessage) + // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.ProcessedMessages) return target; } -size_t OutboundMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:tunnelbroker.OutboundMessage) +size_t ProcessedMessages::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:tunnelbroker.ProcessedMessages) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated string blobHashes = 3; + // repeated string messageID = 1; total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(blobhashes_.size()); - for (int i = 0, n = blobhashes_.size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(messageid_.size()); + for (int i = 0, n = messageid_.size(); i < n; i++) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - blobhashes_.Get(i)); - } - - // string toDeviceID = 1; - if (this->todeviceid().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_todeviceid()); - } - - // string payload = 2; - if (this->payload().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_payload()); + messageid_.Get(i)); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -2488,93 +2542,85 @@ return total_size; } -void OutboundMessage::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.OutboundMessage) +void ProcessedMessages::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.ProcessedMessages) GOOGLE_DCHECK_NE(&from, this); - const OutboundMessage* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const ProcessedMessages* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.OutboundMessage) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.ProcessedMessages) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.OutboundMessage) + // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.ProcessedMessages) MergeFrom(*source); } } -void OutboundMessage::MergeFrom(const OutboundMessage& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.OutboundMessage) +void ProcessedMessages::MergeFrom(const ProcessedMessages& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.ProcessedMessages) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - blobhashes_.MergeFrom(from.blobhashes_); - if (from.todeviceid().size() > 0) { - _internal_set_todeviceid(from._internal_todeviceid()); - } - if (from.payload().size() > 0) { - _internal_set_payload(from._internal_payload()); - } + messageid_.MergeFrom(from.messageid_); } -void OutboundMessage::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.OutboundMessage) +void ProcessedMessages::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.ProcessedMessages) if (&from == this) return; Clear(); MergeFrom(from); } -void OutboundMessage::CopyFrom(const OutboundMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.OutboundMessage) +void ProcessedMessages::CopyFrom(const ProcessedMessages& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.ProcessedMessages) if (&from == this) return; Clear(); MergeFrom(from); } -bool OutboundMessage::IsInitialized() const { +bool ProcessedMessages::IsInitialized() const { return true; } -void OutboundMessage::InternalSwap(OutboundMessage* other) { +void ProcessedMessages::InternalSwap(ProcessedMessages* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - blobhashes_.InternalSwap(&other->blobhashes_); - todeviceid_.Swap(&other->todeviceid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); - payload_.Swap(&other->payload_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + messageid_.InternalSwap(&other->messageid_); } -::PROTOBUF_NAMESPACE_ID::Metadata OutboundMessage::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata ProcessedMessages::GetMetadata() const { return GetMetadataStatic(); } // =================================================================== -class InboundMessage::_Internal { +class MessageToTunnelbrokerStruct::_Internal { public: }; -InboundMessage::InboundMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena) +MessageToTunnelbrokerStruct::MessageToTunnelbrokerStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), blobhashes_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:tunnelbroker.InboundMessage) + // @@protoc_insertion_point(arena_constructor:tunnelbroker.MessageToTunnelbrokerStruct) } -InboundMessage::InboundMessage(const InboundMessage& from) +MessageToTunnelbrokerStruct::MessageToTunnelbrokerStruct(const MessageToTunnelbrokerStruct& from) : ::PROTOBUF_NAMESPACE_ID::Message(), blobhashes_(from.blobhashes_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - fromdeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_fromdeviceid().empty()) { - fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_fromdeviceid(), + messageid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_messageid().empty()) { + messageid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_messageid(), GetArena()); } - fromconnectionid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_fromconnectionid().empty()) { - fromconnectionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_fromconnectionid(), + todeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_todeviceid().empty()) { + todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_todeviceid(), GetArena()); } payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); @@ -2582,73 +2628,73 @@ payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_payload(), GetArena()); } - // @@protoc_insertion_point(copy_constructor:tunnelbroker.InboundMessage) + // @@protoc_insertion_point(copy_constructor:tunnelbroker.MessageToTunnelbrokerStruct) } -void InboundMessage::SharedCtor() { -fromdeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -fromconnectionid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +void MessageToTunnelbrokerStruct::SharedCtor() { +messageid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +todeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -InboundMessage::~InboundMessage() { - // @@protoc_insertion_point(destructor:tunnelbroker.InboundMessage) +MessageToTunnelbrokerStruct::~MessageToTunnelbrokerStruct() { + // @@protoc_insertion_point(destructor:tunnelbroker.MessageToTunnelbrokerStruct) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void InboundMessage::SharedDtor() { +void MessageToTunnelbrokerStruct::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - fromdeviceid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - fromconnectionid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + messageid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + todeviceid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); payload_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -void InboundMessage::ArenaDtor(void* object) { - InboundMessage* _this = reinterpret_cast< InboundMessage* >(object); +void MessageToTunnelbrokerStruct::ArenaDtor(void* object) { + MessageToTunnelbrokerStruct* _this = reinterpret_cast< MessageToTunnelbrokerStruct* >(object); (void)_this; } -void InboundMessage::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +void MessageToTunnelbrokerStruct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } -void InboundMessage::SetCachedSize(int size) const { +void MessageToTunnelbrokerStruct::SetCachedSize(int size) const { _cached_size_.Set(size); } -void InboundMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:tunnelbroker.InboundMessage) +void MessageToTunnelbrokerStruct::Clear() { +// @@protoc_insertion_point(message_clear_start:tunnelbroker.MessageToTunnelbrokerStruct) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; blobhashes_.Clear(); - fromdeviceid_.ClearToEmpty(); - fromconnectionid_.ClearToEmpty(); + messageid_.ClearToEmpty(); + todeviceid_.ClearToEmpty(); payload_.ClearToEmpty(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const char* InboundMessage::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* MessageToTunnelbrokerStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // string fromDeviceID = 1; + // string messageID = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - auto str = _internal_mutable_fromdeviceid(); + auto str = _internal_mutable_messageid(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.InboundMessage.fromDeviceID")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.MessageToTunnelbrokerStruct.messageID")); CHK_(ptr); } else goto handle_unusual; continue; - // string fromConnectionID = 2; + // string toDeviceID = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - auto str = _internal_mutable_fromconnectionid(); + auto str = _internal_mutable_todeviceid(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.InboundMessage.fromConnectionID")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.MessageToTunnelbrokerStruct.toDeviceID")); CHK_(ptr); } else goto handle_unusual; continue; @@ -2657,7 +2703,7 @@ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { auto str = _internal_mutable_payload(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.InboundMessage.payload")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.MessageToTunnelbrokerStruct.payload")); CHK_(ptr); } else goto handle_unusual; continue; @@ -2669,7 +2715,7 @@ ptr += 1; auto str = _internal_add_blobhashes(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.InboundMessage.blobHashes")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.MessageToTunnelbrokerStruct.blobHashes")); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); @@ -2697,30 +2743,30 @@ #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* InboundMessage::_InternalSerialize( +::PROTOBUF_NAMESPACE_ID::uint8* MessageToTunnelbrokerStruct::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.InboundMessage) + // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.MessageToTunnelbrokerStruct) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string fromDeviceID = 1; - if (this->fromdeviceid().size() > 0) { + // string messageID = 1; + if (this->messageid().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_fromdeviceid().data(), static_cast(this->_internal_fromdeviceid().length()), + this->_internal_messageid().data(), static_cast(this->_internal_messageid().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "tunnelbroker.InboundMessage.fromDeviceID"); + "tunnelbroker.MessageToTunnelbrokerStruct.messageID"); target = stream->WriteStringMaybeAliased( - 1, this->_internal_fromdeviceid(), target); + 1, this->_internal_messageid(), target); } - // string fromConnectionID = 2; - if (this->fromconnectionid().size() > 0) { + // string toDeviceID = 2; + if (this->todeviceid().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_fromconnectionid().data(), static_cast(this->_internal_fromconnectionid().length()), + this->_internal_todeviceid().data(), static_cast(this->_internal_todeviceid().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "tunnelbroker.InboundMessage.fromConnectionID"); + "tunnelbroker.MessageToTunnelbrokerStruct.toDeviceID"); target = stream->WriteStringMaybeAliased( - 2, this->_internal_fromconnectionid(), target); + 2, this->_internal_todeviceid(), target); } // string payload = 3; @@ -2728,7 +2774,7 @@ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_payload().data(), static_cast(this->_internal_payload().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "tunnelbroker.InboundMessage.payload"); + "tunnelbroker.MessageToTunnelbrokerStruct.payload"); target = stream->WriteStringMaybeAliased( 3, this->_internal_payload(), target); } @@ -2739,7 +2785,7 @@ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "tunnelbroker.InboundMessage.blobHashes"); + "tunnelbroker.MessageToTunnelbrokerStruct.blobHashes"); target = stream->WriteString(4, s, target); } @@ -2747,12 +2793,12 @@ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.InboundMessage) + // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.MessageToTunnelbrokerStruct) return target; } -size_t InboundMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:tunnelbroker.InboundMessage) +size_t MessageToTunnelbrokerStruct::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:tunnelbroker.MessageToTunnelbrokerStruct) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -2767,18 +2813,18 @@ blobhashes_.Get(i)); } - // string fromDeviceID = 1; - if (this->fromdeviceid().size() > 0) { + // string messageID = 1; + if (this->messageid().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_fromdeviceid()); + this->_internal_messageid()); } - // string fromConnectionID = 2; - if (this->fromconnectionid().size() > 0) { + // string toDeviceID = 2; + if (this->todeviceid().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_fromconnectionid()); + this->_internal_todeviceid()); } // string payload = 3; @@ -2797,161 +2843,142 @@ return total_size; } -void InboundMessage::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.InboundMessage) +void MessageToTunnelbrokerStruct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.MessageToTunnelbrokerStruct) GOOGLE_DCHECK_NE(&from, this); - const InboundMessage* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const MessageToTunnelbrokerStruct* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.InboundMessage) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.MessageToTunnelbrokerStruct) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.InboundMessage) + // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.MessageToTunnelbrokerStruct) MergeFrom(*source); } } -void InboundMessage::MergeFrom(const InboundMessage& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.InboundMessage) +void MessageToTunnelbrokerStruct::MergeFrom(const MessageToTunnelbrokerStruct& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.MessageToTunnelbrokerStruct) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; blobhashes_.MergeFrom(from.blobhashes_); - if (from.fromdeviceid().size() > 0) { - _internal_set_fromdeviceid(from._internal_fromdeviceid()); + if (from.messageid().size() > 0) { + _internal_set_messageid(from._internal_messageid()); } - if (from.fromconnectionid().size() > 0) { - _internal_set_fromconnectionid(from._internal_fromconnectionid()); + if (from.todeviceid().size() > 0) { + _internal_set_todeviceid(from._internal_todeviceid()); } if (from.payload().size() > 0) { _internal_set_payload(from._internal_payload()); } } -void InboundMessage::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.InboundMessage) +void MessageToTunnelbrokerStruct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.MessageToTunnelbrokerStruct) if (&from == this) return; Clear(); MergeFrom(from); } -void InboundMessage::CopyFrom(const InboundMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.InboundMessage) +void MessageToTunnelbrokerStruct::CopyFrom(const MessageToTunnelbrokerStruct& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.MessageToTunnelbrokerStruct) if (&from == this) return; Clear(); MergeFrom(from); } -bool InboundMessage::IsInitialized() const { +bool MessageToTunnelbrokerStruct::IsInitialized() const { return true; } -void InboundMessage::InternalSwap(InboundMessage* other) { +void MessageToTunnelbrokerStruct::InternalSwap(MessageToTunnelbrokerStruct* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); blobhashes_.InternalSwap(&other->blobhashes_); - fromdeviceid_.Swap(&other->fromdeviceid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); - fromconnectionid_.Swap(&other->fromconnectionid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + messageid_.Swap(&other->messageid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + todeviceid_.Swap(&other->todeviceid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); payload_.Swap(&other->payload_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } -::PROTOBUF_NAMESPACE_ID::Metadata InboundMessage::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata MessageToTunnelbrokerStruct::GetMetadata() const { return GetMetadataStatic(); } // =================================================================== -class CheckRequest::_Internal { +class MessagesToSend::_Internal { public: }; -CheckRequest::CheckRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +MessagesToSend::MessagesToSend(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + messages_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:tunnelbroker.CheckRequest) + // @@protoc_insertion_point(arena_constructor:tunnelbroker.MessagesToSend) } -CheckRequest::CheckRequest(const CheckRequest& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { +MessagesToSend::MessagesToSend(const MessagesToSend& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + messages_(from.messages_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_userid().empty()) { - userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(), - GetArena()); - } - devicetoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_devicetoken().empty()) { - devicetoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_devicetoken(), - GetArena()); - } - // @@protoc_insertion_point(copy_constructor:tunnelbroker.CheckRequest) + // @@protoc_insertion_point(copy_constructor:tunnelbroker.MessagesToSend) } -void CheckRequest::SharedCtor() { -userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -devicetoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +void MessagesToSend::SharedCtor() { } -CheckRequest::~CheckRequest() { - // @@protoc_insertion_point(destructor:tunnelbroker.CheckRequest) +MessagesToSend::~MessagesToSend() { + // @@protoc_insertion_point(destructor:tunnelbroker.MessagesToSend) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void CheckRequest::SharedDtor() { +void MessagesToSend::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - devicetoken_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -void CheckRequest::ArenaDtor(void* object) { - CheckRequest* _this = reinterpret_cast< CheckRequest* >(object); +void MessagesToSend::ArenaDtor(void* object) { + MessagesToSend* _this = reinterpret_cast< MessagesToSend* >(object); (void)_this; } -void CheckRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +void MessagesToSend::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } -void CheckRequest::SetCachedSize(int size) const { +void MessagesToSend::SetCachedSize(int size) const { _cached_size_.Set(size); } -void CheckRequest::Clear() { -// @@protoc_insertion_point(message_clear_start:tunnelbroker.CheckRequest) +void MessagesToSend::Clear() { +// @@protoc_insertion_point(message_clear_start:tunnelbroker.MessagesToSend) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - userid_.ClearToEmpty(); - devicetoken_.ClearToEmpty(); + messages_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const char* CheckRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* MessagesToSend::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // string userId = 1; + // repeated .tunnelbroker.MessageToTunnelbrokerStruct messages = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - auto str = _internal_mutable_userid(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.CheckRequest.userId")); - CHK_(ptr); - } else goto handle_unusual; - continue; - // string deviceToken = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - auto str = _internal_mutable_devicetoken(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.CheckRequest.deviceToken")); - CHK_(ptr); + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_messages(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; default: { @@ -2976,60 +3003,41 @@ #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* CheckRequest::_InternalSerialize( +::PROTOBUF_NAMESPACE_ID::uint8* MessagesToSend::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.CheckRequest) + // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.MessagesToSend) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string userId = 1; - if (this->userid().size() > 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_userid().data(), static_cast(this->_internal_userid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "tunnelbroker.CheckRequest.userId"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_userid(), target); - } - - // string deviceToken = 2; - if (this->devicetoken().size() > 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_devicetoken().data(), static_cast(this->_internal_devicetoken().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "tunnelbroker.CheckRequest.deviceToken"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_devicetoken(), target); + // repeated .tunnelbroker.MessageToTunnelbrokerStruct messages = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_messages_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_messages(i), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.CheckRequest) + // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.MessagesToSend) return target; } -size_t CheckRequest::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:tunnelbroker.CheckRequest) +size_t MessagesToSend::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:tunnelbroker.MessagesToSend) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // string userId = 1; - if (this->userid().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_userid()); - } - - // string deviceToken = 2; - if (this->devicetoken().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_devicetoken()); + // repeated .tunnelbroker.MessageToTunnelbrokerStruct messages = 1; + total_size += 1UL * this->_internal_messages_size(); + for (const auto& msg : this->messages_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -3041,14 +3049,1407 @@ return total_size; } -void CheckRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.CheckRequest) +void MessagesToSend::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.MessagesToSend) GOOGLE_DCHECK_NE(&from, this); - const CheckRequest* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const MessagesToSend* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.CheckRequest) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.MessagesToSend) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.MessagesToSend) + MergeFrom(*source); + } +} + +void MessagesToSend::MergeFrom(const MessagesToSend& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.MessagesToSend) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + messages_.MergeFrom(from.messages_); +} + +void MessagesToSend::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.MessagesToSend) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void MessagesToSend::CopyFrom(const MessagesToSend& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.MessagesToSend) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MessagesToSend::IsInitialized() const { + return true; +} + +void MessagesToSend::InternalSwap(MessagesToSend* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + messages_.InternalSwap(&other->messages_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MessagesToSend::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +class MessageToTunnelbroker::_Internal { + public: + static const ::tunnelbroker::MessagesToSend& messagestosend(const MessageToTunnelbroker* msg); + static const ::tunnelbroker::ProcessedMessages& processedmessages(const MessageToTunnelbroker* msg); +}; + +const ::tunnelbroker::MessagesToSend& +MessageToTunnelbroker::_Internal::messagestosend(const MessageToTunnelbroker* msg) { + return *msg->data_.messagestosend_; +} +const ::tunnelbroker::ProcessedMessages& +MessageToTunnelbroker::_Internal::processedmessages(const MessageToTunnelbroker* msg) { + return *msg->data_.processedmessages_; +} +void MessageToTunnelbroker::set_allocated_messagestosend(::tunnelbroker::MessagesToSend* messagestosend) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_data(); + if (messagestosend) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(messagestosend); + if (message_arena != submessage_arena) { + messagestosend = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, messagestosend, submessage_arena); + } + set_has_messagestosend(); + data_.messagestosend_ = messagestosend; + } + // @@protoc_insertion_point(field_set_allocated:tunnelbroker.MessageToTunnelbroker.messagesToSend) +} +void MessageToTunnelbroker::set_allocated_processedmessages(::tunnelbroker::ProcessedMessages* processedmessages) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_data(); + if (processedmessages) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(processedmessages); + if (message_arena != submessage_arena) { + processedmessages = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, processedmessages, submessage_arena); + } + set_has_processedmessages(); + data_.processedmessages_ = processedmessages; + } + // @@protoc_insertion_point(field_set_allocated:tunnelbroker.MessageToTunnelbroker.processedMessages) +} +MessageToTunnelbroker::MessageToTunnelbroker(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:tunnelbroker.MessageToTunnelbroker) +} +MessageToTunnelbroker::MessageToTunnelbroker(const MessageToTunnelbroker& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + sessionid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_sessionid().empty()) { + sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_sessionid(), + GetArena()); + } + clear_has_data(); + switch (from.data_case()) { + case kMessagesToSend: { + _internal_mutable_messagestosend()->::tunnelbroker::MessagesToSend::MergeFrom(from._internal_messagestosend()); + break; + } + case kProcessedMessages: { + _internal_mutable_processedmessages()->::tunnelbroker::ProcessedMessages::MergeFrom(from._internal_processedmessages()); + break; + } + case DATA_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:tunnelbroker.MessageToTunnelbroker) +} + +void MessageToTunnelbroker::SharedCtor() { +sessionid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +clear_has_data(); +} + +MessageToTunnelbroker::~MessageToTunnelbroker() { + // @@protoc_insertion_point(destructor:tunnelbroker.MessageToTunnelbroker) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void MessageToTunnelbroker::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + sessionid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (has_data()) { + clear_data(); + } +} + +void MessageToTunnelbroker::ArenaDtor(void* object) { + MessageToTunnelbroker* _this = reinterpret_cast< MessageToTunnelbroker* >(object); + (void)_this; +} +void MessageToTunnelbroker::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void MessageToTunnelbroker::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void MessageToTunnelbroker::clear_data() { +// @@protoc_insertion_point(one_of_clear_start:tunnelbroker.MessageToTunnelbroker) + switch (data_case()) { + case kMessagesToSend: { + if (GetArena() == nullptr) { + delete data_.messagestosend_; + } + break; + } + case kProcessedMessages: { + if (GetArena() == nullptr) { + delete data_.processedmessages_; + } + break; + } + case DATA_NOT_SET: { + break; + } + } + _oneof_case_[0] = DATA_NOT_SET; +} + + +void MessageToTunnelbroker::Clear() { +// @@protoc_insertion_point(message_clear_start:tunnelbroker.MessageToTunnelbroker) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + sessionid_.ClearToEmpty(); + clear_data(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* MessageToTunnelbroker::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string sessionID = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_sessionid(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.MessageToTunnelbroker.sessionID")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .tunnelbroker.MessagesToSend messagesToSend = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_messagestosend(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .tunnelbroker.ProcessedMessages processedMessages = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_processedmessages(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* MessageToTunnelbroker::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.MessageToTunnelbroker) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string sessionID = 1; + if (this->sessionid().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_sessionid().data(), static_cast(this->_internal_sessionid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "tunnelbroker.MessageToTunnelbroker.sessionID"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_sessionid(), target); + } + + // .tunnelbroker.MessagesToSend messagesToSend = 2; + if (_internal_has_messagestosend()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::messagestosend(this), target, stream); + } + + // .tunnelbroker.ProcessedMessages processedMessages = 3; + if (_internal_has_processedmessages()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::processedmessages(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.MessageToTunnelbroker) + return target; +} + +size_t MessageToTunnelbroker::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:tunnelbroker.MessageToTunnelbroker) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string sessionID = 1; + if (this->sessionid().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_sessionid()); + } + + switch (data_case()) { + // .tunnelbroker.MessagesToSend messagesToSend = 2; + case kMessagesToSend: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *data_.messagestosend_); + break; + } + // .tunnelbroker.ProcessedMessages processedMessages = 3; + case kProcessedMessages: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *data_.processedmessages_); + break; + } + case DATA_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void MessageToTunnelbroker::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.MessageToTunnelbroker) + GOOGLE_DCHECK_NE(&from, this); + const MessageToTunnelbroker* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.MessageToTunnelbroker) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.MessageToTunnelbroker) + MergeFrom(*source); + } +} + +void MessageToTunnelbroker::MergeFrom(const MessageToTunnelbroker& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.MessageToTunnelbroker) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.sessionid().size() > 0) { + _internal_set_sessionid(from._internal_sessionid()); + } + switch (from.data_case()) { + case kMessagesToSend: { + _internal_mutable_messagestosend()->::tunnelbroker::MessagesToSend::MergeFrom(from._internal_messagestosend()); + break; + } + case kProcessedMessages: { + _internal_mutable_processedmessages()->::tunnelbroker::ProcessedMessages::MergeFrom(from._internal_processedmessages()); + break; + } + case DATA_NOT_SET: { + break; + } + } +} + +void MessageToTunnelbroker::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.MessageToTunnelbroker) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void MessageToTunnelbroker::CopyFrom(const MessageToTunnelbroker& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.MessageToTunnelbroker) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MessageToTunnelbroker::IsInitialized() const { + return true; +} + +void MessageToTunnelbroker::InternalSwap(MessageToTunnelbroker* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + sessionid_.Swap(&other->sessionid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + swap(data_, other->data_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MessageToTunnelbroker::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +class MessageToClientStruct::_Internal { + public: +}; + +MessageToClientStruct::MessageToClientStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + blobhashes_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:tunnelbroker.MessageToClientStruct) +} +MessageToClientStruct::MessageToClientStruct(const MessageToClientStruct& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + blobhashes_(from.blobhashes_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + messageid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_messageid().empty()) { + messageid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_messageid(), + GetArena()); + } + fromdeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_fromdeviceid().empty()) { + fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_fromdeviceid(), + GetArena()); + } + payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_payload().empty()) { + payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_payload(), + GetArena()); + } + // @@protoc_insertion_point(copy_constructor:tunnelbroker.MessageToClientStruct) +} + +void MessageToClientStruct::SharedCtor() { +messageid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +fromdeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +MessageToClientStruct::~MessageToClientStruct() { + // @@protoc_insertion_point(destructor:tunnelbroker.MessageToClientStruct) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void MessageToClientStruct::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + messageid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + fromdeviceid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + payload_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void MessageToClientStruct::ArenaDtor(void* object) { + MessageToClientStruct* _this = reinterpret_cast< MessageToClientStruct* >(object); + (void)_this; +} +void MessageToClientStruct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void MessageToClientStruct::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void MessageToClientStruct::Clear() { +// @@protoc_insertion_point(message_clear_start:tunnelbroker.MessageToClientStruct) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + blobhashes_.Clear(); + messageid_.ClearToEmpty(); + fromdeviceid_.ClearToEmpty(); + payload_.ClearToEmpty(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* MessageToClientStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string messageID = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_messageid(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.MessageToClientStruct.messageID")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string fromDeviceID = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_fromdeviceid(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.MessageToClientStruct.fromDeviceID")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string payload = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_payload(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.MessageToClientStruct.payload")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string blobHashes = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_blobhashes(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.MessageToClientStruct.blobHashes")); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* MessageToClientStruct::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.MessageToClientStruct) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string messageID = 1; + if (this->messageid().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_messageid().data(), static_cast(this->_internal_messageid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "tunnelbroker.MessageToClientStruct.messageID"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_messageid(), target); + } + + // string fromDeviceID = 2; + if (this->fromdeviceid().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_fromdeviceid().data(), static_cast(this->_internal_fromdeviceid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "tunnelbroker.MessageToClientStruct.fromDeviceID"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_fromdeviceid(), target); + } + + // string payload = 3; + if (this->payload().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_payload().data(), static_cast(this->_internal_payload().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "tunnelbroker.MessageToClientStruct.payload"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_payload(), target); + } + + // repeated string blobHashes = 4; + for (int i = 0, n = this->_internal_blobhashes_size(); i < n; i++) { + const auto& s = this->_internal_blobhashes(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "tunnelbroker.MessageToClientStruct.blobHashes"); + target = stream->WriteString(4, s, target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.MessageToClientStruct) + return target; +} + +size_t MessageToClientStruct::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:tunnelbroker.MessageToClientStruct) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string blobHashes = 4; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(blobhashes_.size()); + for (int i = 0, n = blobhashes_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + blobhashes_.Get(i)); + } + + // string messageID = 1; + if (this->messageid().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_messageid()); + } + + // string fromDeviceID = 2; + if (this->fromdeviceid().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_fromdeviceid()); + } + + // string payload = 3; + if (this->payload().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_payload()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void MessageToClientStruct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.MessageToClientStruct) + GOOGLE_DCHECK_NE(&from, this); + const MessageToClientStruct* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.MessageToClientStruct) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.MessageToClientStruct) + MergeFrom(*source); + } +} + +void MessageToClientStruct::MergeFrom(const MessageToClientStruct& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.MessageToClientStruct) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + blobhashes_.MergeFrom(from.blobhashes_); + if (from.messageid().size() > 0) { + _internal_set_messageid(from._internal_messageid()); + } + if (from.fromdeviceid().size() > 0) { + _internal_set_fromdeviceid(from._internal_fromdeviceid()); + } + if (from.payload().size() > 0) { + _internal_set_payload(from._internal_payload()); + } +} + +void MessageToClientStruct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.MessageToClientStruct) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void MessageToClientStruct::CopyFrom(const MessageToClientStruct& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.MessageToClientStruct) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MessageToClientStruct::IsInitialized() const { + return true; +} + +void MessageToClientStruct::InternalSwap(MessageToClientStruct* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + blobhashes_.InternalSwap(&other->blobhashes_); + messageid_.Swap(&other->messageid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + fromdeviceid_.Swap(&other->fromdeviceid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + payload_.Swap(&other->payload_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MessageToClientStruct::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +class MessagesToDeliver::_Internal { + public: +}; + +MessagesToDeliver::MessagesToDeliver(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + messages_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:tunnelbroker.MessagesToDeliver) +} +MessagesToDeliver::MessagesToDeliver(const MessagesToDeliver& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + messages_(from.messages_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:tunnelbroker.MessagesToDeliver) +} + +void MessagesToDeliver::SharedCtor() { +} + +MessagesToDeliver::~MessagesToDeliver() { + // @@protoc_insertion_point(destructor:tunnelbroker.MessagesToDeliver) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void MessagesToDeliver::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void MessagesToDeliver::ArenaDtor(void* object) { + MessagesToDeliver* _this = reinterpret_cast< MessagesToDeliver* >(object); + (void)_this; +} +void MessagesToDeliver::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void MessagesToDeliver::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void MessagesToDeliver::Clear() { +// @@protoc_insertion_point(message_clear_start:tunnelbroker.MessagesToDeliver) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + messages_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* MessagesToDeliver::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // repeated .tunnelbroker.MessageToClientStruct messages = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_messages(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* MessagesToDeliver::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.MessagesToDeliver) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .tunnelbroker.MessageToClientStruct messages = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_messages_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_messages(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.MessagesToDeliver) + return target; +} + +size_t MessagesToDeliver::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:tunnelbroker.MessagesToDeliver) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .tunnelbroker.MessageToClientStruct messages = 1; + total_size += 1UL * this->_internal_messages_size(); + for (const auto& msg : this->messages_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void MessagesToDeliver::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.MessagesToDeliver) + GOOGLE_DCHECK_NE(&from, this); + const MessagesToDeliver* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.MessagesToDeliver) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.MessagesToDeliver) + MergeFrom(*source); + } +} + +void MessagesToDeliver::MergeFrom(const MessagesToDeliver& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.MessagesToDeliver) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + messages_.MergeFrom(from.messages_); +} + +void MessagesToDeliver::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.MessagesToDeliver) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void MessagesToDeliver::CopyFrom(const MessagesToDeliver& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.MessagesToDeliver) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MessagesToDeliver::IsInitialized() const { + return true; +} + +void MessagesToDeliver::InternalSwap(MessagesToDeliver* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + messages_.InternalSwap(&other->messages_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MessagesToDeliver::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +class MessageToClient::_Internal { + public: + static const ::tunnelbroker::MessagesToDeliver& messagestodeliver(const MessageToClient* msg); + static const ::tunnelbroker::ProcessedMessages& processedmessages(const MessageToClient* msg); +}; + +const ::tunnelbroker::MessagesToDeliver& +MessageToClient::_Internal::messagestodeliver(const MessageToClient* msg) { + return *msg->data_.messagestodeliver_; +} +const ::tunnelbroker::ProcessedMessages& +MessageToClient::_Internal::processedmessages(const MessageToClient* msg) { + return *msg->data_.processedmessages_; +} +void MessageToClient::set_allocated_messagestodeliver(::tunnelbroker::MessagesToDeliver* messagestodeliver) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_data(); + if (messagestodeliver) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(messagestodeliver); + if (message_arena != submessage_arena) { + messagestodeliver = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, messagestodeliver, submessage_arena); + } + set_has_messagestodeliver(); + data_.messagestodeliver_ = messagestodeliver; + } + // @@protoc_insertion_point(field_set_allocated:tunnelbroker.MessageToClient.messagesToDeliver) +} +void MessageToClient::set_allocated_processedmessages(::tunnelbroker::ProcessedMessages* processedmessages) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_data(); + if (processedmessages) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(processedmessages); + if (message_arena != submessage_arena) { + processedmessages = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, processedmessages, submessage_arena); + } + set_has_processedmessages(); + data_.processedmessages_ = processedmessages; + } + // @@protoc_insertion_point(field_set_allocated:tunnelbroker.MessageToClient.processedMessages) +} +MessageToClient::MessageToClient(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:tunnelbroker.MessageToClient) +} +MessageToClient::MessageToClient(const MessageToClient& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_data(); + switch (from.data_case()) { + case kMessagesToDeliver: { + _internal_mutable_messagestodeliver()->::tunnelbroker::MessagesToDeliver::MergeFrom(from._internal_messagestodeliver()); + break; + } + case kProcessedMessages: { + _internal_mutable_processedmessages()->::tunnelbroker::ProcessedMessages::MergeFrom(from._internal_processedmessages()); + break; + } + case DATA_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:tunnelbroker.MessageToClient) +} + +void MessageToClient::SharedCtor() { +clear_has_data(); +} + +MessageToClient::~MessageToClient() { + // @@protoc_insertion_point(destructor:tunnelbroker.MessageToClient) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void MessageToClient::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_data()) { + clear_data(); + } +} + +void MessageToClient::ArenaDtor(void* object) { + MessageToClient* _this = reinterpret_cast< MessageToClient* >(object); + (void)_this; +} +void MessageToClient::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void MessageToClient::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void MessageToClient::clear_data() { +// @@protoc_insertion_point(one_of_clear_start:tunnelbroker.MessageToClient) + switch (data_case()) { + case kMessagesToDeliver: { + if (GetArena() == nullptr) { + delete data_.messagestodeliver_; + } + break; + } + case kProcessedMessages: { + if (GetArena() == nullptr) { + delete data_.processedmessages_; + } + break; + } + case DATA_NOT_SET: { + break; + } + } + _oneof_case_[0] = DATA_NOT_SET; +} + + +void MessageToClient::Clear() { +// @@protoc_insertion_point(message_clear_start:tunnelbroker.MessageToClient) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_data(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* MessageToClient::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // .tunnelbroker.MessagesToDeliver messagesToDeliver = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_messagestodeliver(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .tunnelbroker.ProcessedMessages processedMessages = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_processedmessages(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* MessageToClient::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.MessageToClient) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .tunnelbroker.MessagesToDeliver messagesToDeliver = 1; + if (_internal_has_messagestodeliver()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::messagestodeliver(this), target, stream); + } + + // .tunnelbroker.ProcessedMessages processedMessages = 2; + if (_internal_has_processedmessages()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::processedmessages(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.MessageToClient) + return target; +} + +size_t MessageToClient::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:tunnelbroker.MessageToClient) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (data_case()) { + // .tunnelbroker.MessagesToDeliver messagesToDeliver = 1; + case kMessagesToDeliver: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *data_.messagestodeliver_); + break; + } + // .tunnelbroker.ProcessedMessages processedMessages = 2; + case kProcessedMessages: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *data_.processedmessages_); + break; + } + case DATA_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void MessageToClient::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.MessageToClient) + GOOGLE_DCHECK_NE(&from, this); + const MessageToClient* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.MessageToClient) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.MessageToClient) + MergeFrom(*source); + } +} + +void MessageToClient::MergeFrom(const MessageToClient& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.MessageToClient) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.data_case()) { + case kMessagesToDeliver: { + _internal_mutable_messagestodeliver()->::tunnelbroker::MessagesToDeliver::MergeFrom(from._internal_messagestodeliver()); + break; + } + case kProcessedMessages: { + _internal_mutable_processedmessages()->::tunnelbroker::ProcessedMessages::MergeFrom(from._internal_processedmessages()); + break; + } + case DATA_NOT_SET: { + break; + } + } +} + +void MessageToClient::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.MessageToClient) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void MessageToClient::CopyFrom(const MessageToClient& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.MessageToClient) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MessageToClient::IsInitialized() const { + return true; +} + +void MessageToClient::InternalSwap(MessageToClient* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(data_, other->data_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MessageToClient::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +class CheckRequest::_Internal { + public: +}; + +CheckRequest::CheckRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:tunnelbroker.CheckRequest) +} +CheckRequest::CheckRequest(const CheckRequest& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_userid().empty()) { + userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(), + GetArena()); + } + devicetoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_devicetoken().empty()) { + devicetoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_devicetoken(), + GetArena()); + } + // @@protoc_insertion_point(copy_constructor:tunnelbroker.CheckRequest) +} + +void CheckRequest::SharedCtor() { +userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +devicetoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +CheckRequest::~CheckRequest() { + // @@protoc_insertion_point(destructor:tunnelbroker.CheckRequest) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void CheckRequest::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + devicetoken_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void CheckRequest::ArenaDtor(void* object) { + CheckRequest* _this = reinterpret_cast< CheckRequest* >(object); + (void)_this; +} +void CheckRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void CheckRequest::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void CheckRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:tunnelbroker.CheckRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + userid_.ClearToEmpty(); + devicetoken_.ClearToEmpty(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* CheckRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string userId = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_userid(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.CheckRequest.userId")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string deviceToken = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_devicetoken(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.CheckRequest.deviceToken")); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* CheckRequest::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.CheckRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string userId = 1; + if (this->userid().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_userid().data(), static_cast(this->_internal_userid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "tunnelbroker.CheckRequest.userId"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_userid(), target); + } + + // string deviceToken = 2; + if (this->devicetoken().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_devicetoken().data(), static_cast(this->_internal_devicetoken().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "tunnelbroker.CheckRequest.deviceToken"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_devicetoken(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.CheckRequest) + return target; +} + +size_t CheckRequest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:tunnelbroker.CheckRequest) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string userId = 1; + if (this->userid().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_userid()); + } + + // string deviceToken = 2; + if (this->devicetoken().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_devicetoken()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void CheckRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.CheckRequest) + GOOGLE_DCHECK_NE(&from, this); + const CheckRequest* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.CheckRequest) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.CheckRequest) @@ -3978,11 +5379,26 @@ template<> PROTOBUF_NOINLINE ::tunnelbroker::GetResponse* Arena::CreateMaybeMessage< ::tunnelbroker::GetResponse >(Arena* arena) { return Arena::CreateMessageInternal< ::tunnelbroker::GetResponse >(arena); } -template<> PROTOBUF_NOINLINE ::tunnelbroker::OutboundMessage* Arena::CreateMaybeMessage< ::tunnelbroker::OutboundMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::tunnelbroker::OutboundMessage >(arena); +template<> PROTOBUF_NOINLINE ::tunnelbroker::ProcessedMessages* Arena::CreateMaybeMessage< ::tunnelbroker::ProcessedMessages >(Arena* arena) { + return Arena::CreateMessageInternal< ::tunnelbroker::ProcessedMessages >(arena); +} +template<> PROTOBUF_NOINLINE ::tunnelbroker::MessageToTunnelbrokerStruct* Arena::CreateMaybeMessage< ::tunnelbroker::MessageToTunnelbrokerStruct >(Arena* arena) { + return Arena::CreateMessageInternal< ::tunnelbroker::MessageToTunnelbrokerStruct >(arena); +} +template<> PROTOBUF_NOINLINE ::tunnelbroker::MessagesToSend* Arena::CreateMaybeMessage< ::tunnelbroker::MessagesToSend >(Arena* arena) { + return Arena::CreateMessageInternal< ::tunnelbroker::MessagesToSend >(arena); +} +template<> PROTOBUF_NOINLINE ::tunnelbroker::MessageToTunnelbroker* Arena::CreateMaybeMessage< ::tunnelbroker::MessageToTunnelbroker >(Arena* arena) { + return Arena::CreateMessageInternal< ::tunnelbroker::MessageToTunnelbroker >(arena); +} +template<> PROTOBUF_NOINLINE ::tunnelbroker::MessageToClientStruct* Arena::CreateMaybeMessage< ::tunnelbroker::MessageToClientStruct >(Arena* arena) { + return Arena::CreateMessageInternal< ::tunnelbroker::MessageToClientStruct >(arena); +} +template<> PROTOBUF_NOINLINE ::tunnelbroker::MessagesToDeliver* Arena::CreateMaybeMessage< ::tunnelbroker::MessagesToDeliver >(Arena* arena) { + return Arena::CreateMessageInternal< ::tunnelbroker::MessagesToDeliver >(arena); } -template<> PROTOBUF_NOINLINE ::tunnelbroker::InboundMessage* Arena::CreateMaybeMessage< ::tunnelbroker::InboundMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::tunnelbroker::InboundMessage >(arena); +template<> PROTOBUF_NOINLINE ::tunnelbroker::MessageToClient* Arena::CreateMaybeMessage< ::tunnelbroker::MessageToClient >(Arena* arena) { + return Arena::CreateMessageInternal< ::tunnelbroker::MessageToClient >(arena); } template<> PROTOBUF_NOINLINE ::tunnelbroker::CheckRequest* Arena::CreateMaybeMessage< ::tunnelbroker::CheckRequest >(Arena* arena) { return Arena::CreateMessageInternal< ::tunnelbroker::CheckRequest >(arena);