diff --git a/rpcs3/Emu/Cell/Modules/sceNp2.cpp b/rpcs3/Emu/Cell/Modules/sceNp2.cpp index fddc514bcc..c9816b60f5 100644 --- a/rpcs3/Emu/Cell/Modules/sceNp2.cpp +++ b/rpcs3/Emu/Cell/Modules/sceNp2.cpp @@ -798,7 +798,7 @@ error_code sceNpMatching2JoinLobby( error_code sceNpMatching2GetRoomMemberDataExternalList(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - sceNp2.todo("sceNpMatching2GetRoomMemberDataExternalList(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + sceNp2.warning("sceNpMatching2GetRoomMemberDataExternalList(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); auto& nph = g_fxo->get>(); if (auto res = generic_match2_error_check(nph, ctxId, reqParam); res != CELL_OK) @@ -806,6 +806,13 @@ error_code sceNpMatching2GetRoomMemberDataExternalList(SceNpMatching2ContextId c return res; } + const u32 request_id = nph.get_room_member_data_external_list(ctxId, optParam, reqParam.get_ptr()); + + if (assignedReqId) + { + *assignedReqId = request_id; + } + return CELL_OK; } diff --git a/rpcs3/Emu/NP/generated/np2_structs.pb.cc b/rpcs3/Emu/NP/generated/np2_structs.pb.cc index 6416723f11..2a4c4f6241 100644 --- a/rpcs3/Emu/NP/generated/np2_structs.pb.cc +++ b/rpcs3/Emu/NP/generated/np2_structs.pb.cc @@ -1299,6 +1299,33 @@ struct RoomMessageInfoDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RoomMessageInfoDefaultTypeInternal _RoomMessageInfo_default_instance_; +inline constexpr RoomMemberDataExternal::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + userinfo_{nullptr}, + role_{nullptr}, + joindate_{::uint64_t{0u}} {} + +template +PROTOBUF_CONSTEXPR RoomMemberDataExternal::RoomMemberDataExternal(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(RoomMemberDataExternal_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct RoomMemberDataExternalDefaultTypeInternal { + PROTOBUF_CONSTEXPR RoomMemberDataExternalDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RoomMemberDataExternalDefaultTypeInternal() {} + union { + RoomMemberDataExternal _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RoomMemberDataExternalDefaultTypeInternal _RoomMemberDataExternal_default_instance_; + inline constexpr RoomGroupPasswordConfig::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, @@ -2161,6 +2188,31 @@ struct IntSearchFilterDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IntSearchFilterDefaultTypeInternal _IntSearchFilter_default_instance_; +inline constexpr GetRoomMemberDataExternalListResponse::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + members_{} {} + +template +PROTOBUF_CONSTEXPR GetRoomMemberDataExternalListResponse::GetRoomMemberDataExternalListResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(GetRoomMemberDataExternalListResponse_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct GetRoomMemberDataExternalListResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR GetRoomMemberDataExternalListResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~GetRoomMemberDataExternalListResponseDefaultTypeInternal() {} + union { + GetRoomMemberDataExternalListResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetRoomMemberDataExternalListResponseDefaultTypeInternal _GetRoomMemberDataExternalListResponse_default_instance_; + inline constexpr CreateJoinRoomRequest::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, @@ -36071,6 +36123,635 @@ void MatchingSearchJoinRoomInfo::InternalSwap(MatchingSearchJoinRoomInfo* PROTOB swap(_impl_.room_, other->_impl_.room_); } +// =================================================================== + +class RoomMemberDataExternal::_Internal { + public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(RoomMemberDataExternal, _impl_._has_bits_); +}; + +RoomMemberDataExternal::RoomMemberDataExternal(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, RoomMemberDataExternal_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:np2_structs.RoomMemberDataExternal) +} +PROTOBUF_NDEBUG_INLINE RoomMemberDataExternal::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::np2_structs::RoomMemberDataExternal& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0} {} + +RoomMemberDataExternal::RoomMemberDataExternal( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, + const RoomMemberDataExternal& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, RoomMemberDataExternal_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + RoomMemberDataExternal* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::std::string>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.userinfo_ = (CheckHasBit(cached_has_bits, 0x00000001U)) + ? ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.userinfo_) + : nullptr; + _impl_.role_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.role_) + : nullptr; + _impl_.joindate_ = from._impl_.joindate_; + + // @@protoc_insertion_point(copy_constructor:np2_structs.RoomMemberDataExternal) +} +PROTOBUF_NDEBUG_INLINE RoomMemberDataExternal::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0} {} + +inline void RoomMemberDataExternal::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, userinfo_), + 0, + offsetof(Impl_, joindate_) - + offsetof(Impl_, userinfo_) + + sizeof(Impl_::joindate_)); +} +RoomMemberDataExternal::~RoomMemberDataExternal() { + // @@protoc_insertion_point(destructor:np2_structs.RoomMemberDataExternal) + SharedDtor(*this); +} +inline void RoomMemberDataExternal::SharedDtor(MessageLite& self) { + RoomMemberDataExternal& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::std::string>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + delete this_._impl_.userinfo_; + delete this_._impl_.role_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL RoomMemberDataExternal::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) RoomMemberDataExternal(arena); +} +constexpr auto RoomMemberDataExternal::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(RoomMemberDataExternal), + alignof(RoomMemberDataExternal)); +} +constexpr auto RoomMemberDataExternal::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataLite<35>{ + { + &_RoomMemberDataExternal_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RoomMemberDataExternal::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RoomMemberDataExternal::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &RoomMemberDataExternal::ByteSizeLong, + &RoomMemberDataExternal::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RoomMemberDataExternal, _impl_._cached_size_), + true, + }, + "np2_structs.RoomMemberDataExternal", + }; +} + +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<35> RoomMemberDataExternal_class_data_ = + RoomMemberDataExternal::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +RoomMemberDataExternal::GetClassData() const { + return RoomMemberDataExternal_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 2, 0, 2> +RoomMemberDataExternal::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RoomMemberDataExternal, _impl_._has_bits_), + 0, // no _extensions_ + 3, 24, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967288, // skipmap + offsetof(decltype(_table_), field_entries), + 3, // num_field_entries + 2, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + RoomMemberDataExternal_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::np2_structs::RoomMemberDataExternal>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // .np2_structs.UserInfo userInfo = 1; + {::_pbi::TcParser::FastMtS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(RoomMemberDataExternal, _impl_.userinfo_)}}, + // uint64 joinDate = 2; + {::_pbi::TcParser::FastV64S1, + {16, 2, 0, + PROTOBUF_FIELD_OFFSET(RoomMemberDataExternal, _impl_.joindate_)}}, + // .np2_structs.uint8 role = 3; + {::_pbi::TcParser::FastMtS1, + {26, 1, 1, + PROTOBUF_FIELD_OFFSET(RoomMemberDataExternal, _impl_.role_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .np2_structs.UserInfo userInfo = 1; + {PROTOBUF_FIELD_OFFSET(RoomMemberDataExternal, _impl_.userinfo_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // uint64 joinDate = 2; + {PROTOBUF_FIELD_OFFSET(RoomMemberDataExternal, _impl_.joindate_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + // .np2_structs.uint8 role = 3; + {PROTOBUF_FIELD_OFFSET(RoomMemberDataExternal, _impl_.role_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::np2_structs::UserInfo>()}, + {::_pbi::TcParser::GetTable<::np2_structs::uint8>()}, + }}, + {{ + }}, +}; +PROTOBUF_NOINLINE void RoomMemberDataExternal::Clear() { +// @@protoc_insertion_point(message_clear_start:np2_structs.RoomMemberDataExternal) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + ABSL_DCHECK(_impl_.userinfo_ != nullptr); + _impl_.userinfo_->Clear(); + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + ABSL_DCHECK(_impl_.role_ != nullptr); + _impl_.role_->Clear(); + } + } + _impl_.joindate_ = ::uint64_t{0u}; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::std::string>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::uint8_t* PROTOBUF_NONNULL RoomMemberDataExternal::_InternalSerialize( + const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { + const RoomMemberDataExternal& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::uint8_t* PROTOBUF_NONNULL RoomMemberDataExternal::_InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + const RoomMemberDataExternal& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(serialize_to_array_start:np2_structs.RoomMemberDataExternal) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // .np2_structs.UserInfo userInfo = 1; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.userinfo_, this_._impl_.userinfo_->GetCachedSize(), target, + stream); + } + + // uint64 joinDate = 2; + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (this_._internal_joindate() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray( + 2, this_._internal_joindate(), target); + } + } + + // .np2_structs.uint8 role = 3; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 3, *this_._impl_.role_, this_._impl_.role_->GetCachedSize(), target, + stream); + } + + if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:np2_structs.RoomMemberDataExternal) + return target; +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::size_t RoomMemberDataExternal::ByteSizeLong(const MessageLite& base) { + const RoomMemberDataExternal& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::size_t RoomMemberDataExternal::ByteSizeLong() const { + const RoomMemberDataExternal& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:np2_structs.RoomMemberDataExternal) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + cached_has_bits = this_._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + // .np2_structs.UserInfo userInfo = 1; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.userinfo_); + } + // .np2_structs.uint8 role = 3; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.role_); + } + // uint64 joinDate = 2; + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (this_._internal_joindate() != 0) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( + this_._internal_joindate()); + } + } + } + if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; +} + +void RoomMemberDataExternal::MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = + static_cast(&to_msg); + auto& from = static_cast(from_msg); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + from.CheckHasBitConsistency(); + } + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:np2_structs.RoomMemberDataExternal) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + ABSL_DCHECK(from._impl_.userinfo_ != nullptr); + if (_this->_impl_.userinfo_ == nullptr) { + _this->_impl_.userinfo_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.userinfo_); + } else { + _this->_impl_.userinfo_->MergeFrom(*from._impl_.userinfo_); + } + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + ABSL_DCHECK(from._impl_.role_ != nullptr); + if (_this->_impl_.role_ == nullptr) { + _this->_impl_.role_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.role_); + } else { + _this->_impl_.role_->MergeFrom(*from._impl_.role_); + } + } + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (from._internal_joindate() != 0) { + _this->_impl_.joindate_ = from._impl_.joindate_; + } + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::std::string>( + from._internal_metadata_); +} + +void RoomMemberDataExternal::CopyFrom(const RoomMemberDataExternal& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:np2_structs.RoomMemberDataExternal) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void RoomMemberDataExternal::InternalSwap(RoomMemberDataExternal* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(RoomMemberDataExternal, _impl_.joindate_) + + sizeof(RoomMemberDataExternal::_impl_.joindate_) + - PROTOBUF_FIELD_OFFSET(RoomMemberDataExternal, _impl_.userinfo_)>( + reinterpret_cast(&_impl_.userinfo_), + reinterpret_cast(&other->_impl_.userinfo_)); +} + +// =================================================================== + +class GetRoomMemberDataExternalListResponse::_Internal { + public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(GetRoomMemberDataExternalListResponse, _impl_._has_bits_); +}; + +GetRoomMemberDataExternalListResponse::GetRoomMemberDataExternalListResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, GetRoomMemberDataExternalListResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:np2_structs.GetRoomMemberDataExternalListResponse) +} +PROTOBUF_NDEBUG_INLINE GetRoomMemberDataExternalListResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::np2_structs::GetRoomMemberDataExternalListResponse& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + members_{visibility, arena, from.members_} {} + +GetRoomMemberDataExternalListResponse::GetRoomMemberDataExternalListResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, + const GetRoomMemberDataExternalListResponse& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, GetRoomMemberDataExternalListResponse_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + GetRoomMemberDataExternalListResponse* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::std::string>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + + // @@protoc_insertion_point(copy_constructor:np2_structs.GetRoomMemberDataExternalListResponse) +} +PROTOBUF_NDEBUG_INLINE GetRoomMemberDataExternalListResponse::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + members_{visibility, arena} {} + +inline void GetRoomMemberDataExternalListResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +GetRoomMemberDataExternalListResponse::~GetRoomMemberDataExternalListResponse() { + // @@protoc_insertion_point(destructor:np2_structs.GetRoomMemberDataExternalListResponse) + SharedDtor(*this); +} +inline void GetRoomMemberDataExternalListResponse::SharedDtor(MessageLite& self) { + GetRoomMemberDataExternalListResponse& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::std::string>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL GetRoomMemberDataExternalListResponse::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) GetRoomMemberDataExternalListResponse(arena); +} +constexpr auto GetRoomMemberDataExternalListResponse::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(GetRoomMemberDataExternalListResponse, _impl_.members_) + + decltype(GetRoomMemberDataExternalListResponse::_impl_.members_):: + InternalGetArenaOffset( + ::google::protobuf::MessageLite::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::ZeroInit( + sizeof(GetRoomMemberDataExternalListResponse), alignof(GetRoomMemberDataExternalListResponse), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&GetRoomMemberDataExternalListResponse::PlacementNew_, + sizeof(GetRoomMemberDataExternalListResponse), + alignof(GetRoomMemberDataExternalListResponse)); + } +} +constexpr auto GetRoomMemberDataExternalListResponse::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataLite<50>{ + { + &_GetRoomMemberDataExternalListResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &GetRoomMemberDataExternalListResponse::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &GetRoomMemberDataExternalListResponse::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &GetRoomMemberDataExternalListResponse::ByteSizeLong, + &GetRoomMemberDataExternalListResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(GetRoomMemberDataExternalListResponse, _impl_._cached_size_), + true, + }, + "np2_structs.GetRoomMemberDataExternalListResponse", + }; +} + +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<50> GetRoomMemberDataExternalListResponse_class_data_ = + GetRoomMemberDataExternalListResponse::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +GetRoomMemberDataExternalListResponse::GetClassData() const { + return GetRoomMemberDataExternalListResponse_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 1, 0, 2> +GetRoomMemberDataExternalListResponse::_table_ = { + { + PROTOBUF_FIELD_OFFSET(GetRoomMemberDataExternalListResponse, _impl_._has_bits_), + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + GetRoomMemberDataExternalListResponse_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::np2_structs::GetRoomMemberDataExternalListResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // repeated .np2_structs.RoomMemberDataExternal members = 1; + {::_pbi::TcParser::FastMtR1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(GetRoomMemberDataExternalListResponse, _impl_.members_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // repeated .np2_structs.RoomMemberDataExternal members = 1; + {PROTOBUF_FIELD_OFFSET(GetRoomMemberDataExternalListResponse, _impl_.members_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::np2_structs::RoomMemberDataExternal>()}, + }}, + {{ + }}, +}; +PROTOBUF_NOINLINE void GetRoomMemberDataExternalListResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:np2_structs.GetRoomMemberDataExternalListResponse) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { + _impl_.members_.Clear(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::std::string>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::uint8_t* PROTOBUF_NONNULL GetRoomMemberDataExternalListResponse::_InternalSerialize( + const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { + const GetRoomMemberDataExternalListResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::uint8_t* PROTOBUF_NONNULL GetRoomMemberDataExternalListResponse::_InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + const GetRoomMemberDataExternalListResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(serialize_to_array_start:np2_structs.GetRoomMemberDataExternalListResponse) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // repeated .np2_structs.RoomMemberDataExternal members = 1; + if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { + for (unsigned i = 0, n = static_cast( + this_._internal_members_size()); + i < n; i++) { + const auto& repfield = this_._internal_members().Get(i); + target = + ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, repfield, repfield.GetCachedSize(), + target, stream); + } + } + + if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:np2_structs.GetRoomMemberDataExternalListResponse) + return target; +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::size_t GetRoomMemberDataExternalListResponse::ByteSizeLong(const MessageLite& base) { + const GetRoomMemberDataExternalListResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::size_t GetRoomMemberDataExternalListResponse::ByteSizeLong() const { + const GetRoomMemberDataExternalListResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:np2_structs.GetRoomMemberDataExternalListResponse) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // repeated .np2_structs.RoomMemberDataExternal members = 1; + cached_has_bits = this_._impl_._has_bits_[0]; + if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { + total_size += 1UL * this_._internal_members_size(); + for (const auto& msg : this_._internal_members()) { + total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + } + } + if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; +} + +void GetRoomMemberDataExternalListResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = + static_cast(&to_msg); + auto& from = static_cast(from_msg); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + from.CheckHasBitConsistency(); + } + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:np2_structs.GetRoomMemberDataExternalListResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { + _this->_internal_mutable_members()->InternalMergeFromWithArena( + ::google::protobuf::MessageLite::internal_visibility(), arena, + from._internal_members()); + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::std::string>( + from._internal_metadata_); +} + +void GetRoomMemberDataExternalListResponse::CopyFrom(const GetRoomMemberDataExternalListResponse& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:np2_structs.GetRoomMemberDataExternalListResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void GetRoomMemberDataExternalListResponse::InternalSwap(GetRoomMemberDataExternalListResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.members_.InternalSwap(&other->_impl_.members_); +} + // @@protoc_insertion_point(namespace_scope) } // namespace np2_structs namespace google { diff --git a/rpcs3/Emu/NP/generated/np2_structs.pb.h b/rpcs3/Emu/NP/generated/np2_structs.pb.h index 0e035973fd..4e435b3b07 100644 --- a/rpcs3/Emu/NP/generated/np2_structs.pb.h +++ b/rpcs3/Emu/NP/generated/np2_structs.pb.h @@ -99,6 +99,10 @@ class GetRoomListGUIRequest; struct GetRoomListGUIRequestDefaultTypeInternal; extern GetRoomListGUIRequestDefaultTypeInternal _GetRoomListGUIRequest_default_instance_; extern const ::google::protobuf::internal::ClassDataLite<34> GetRoomListGUIRequest_class_data_; +class GetRoomMemberDataExternalListResponse; +struct GetRoomMemberDataExternalListResponseDefaultTypeInternal; +extern GetRoomMemberDataExternalListResponseDefaultTypeInternal _GetRoomMemberDataExternalListResponse_default_instance_; +extern const ::google::protobuf::internal::ClassDataLite<50> GetRoomMemberDataExternalListResponse_class_data_; class GetRoomMemberDataInternalRequest; struct GetRoomMemberDataInternalRequestDefaultTypeInternal; extern GetRoomMemberDataInternalRequestDefaultTypeInternal _GetRoomMemberDataInternalRequest_default_instance_; @@ -235,6 +239,10 @@ class RoomMemberBinAttrInternal; struct RoomMemberBinAttrInternalDefaultTypeInternal; extern RoomMemberBinAttrInternalDefaultTypeInternal _RoomMemberBinAttrInternal_default_instance_; extern const ::google::protobuf::internal::ClassDataLite<38> RoomMemberBinAttrInternal_class_data_; +class RoomMemberDataExternal; +struct RoomMemberDataExternalDefaultTypeInternal; +extern RoomMemberDataExternalDefaultTypeInternal _RoomMemberDataExternal_default_instance_; +extern const ::google::protobuf::internal::ClassDataLite<35> RoomMemberDataExternal_class_data_; class RoomMemberDataInternal; struct RoomMemberDataInternalDefaultTypeInternal; extern RoomMemberDataInternalDefaultTypeInternal _RoomMemberDataInternal_default_instance_; @@ -9818,6 +9826,218 @@ class RoomMessageInfo final : public ::google::protobuf::MessageLite extern const ::google::protobuf::internal::ClassDataLite<28> RoomMessageInfo_class_data_; // ------------------------------------------------------------------- +class RoomMemberDataExternal final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:np2_structs.RoomMemberDataExternal) */ { + public: + inline RoomMemberDataExternal() : RoomMemberDataExternal(nullptr) {} + ~RoomMemberDataExternal() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RoomMemberDataExternal* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RoomMemberDataExternal)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR RoomMemberDataExternal(::google::protobuf::internal::ConstantInitialized); + + inline RoomMemberDataExternal(const RoomMemberDataExternal& from) : RoomMemberDataExternal(nullptr, from) {} + inline RoomMemberDataExternal(RoomMemberDataExternal&& from) noexcept + : RoomMemberDataExternal(nullptr, ::std::move(from)) {} + inline RoomMemberDataExternal& operator=(const RoomMemberDataExternal& from) { + CopyFrom(from); + return *this; + } + inline RoomMemberDataExternal& operator=(RoomMemberDataExternal&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString); + } + inline ::std::string* PROTOBUF_NONNULL mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::std::string>(); + } + + static const RoomMemberDataExternal& default_instance() { + return *reinterpret_cast( + &_RoomMemberDataExternal_default_instance_); + } + static constexpr int kIndexInFileMessages = 89; + friend void swap(RoomMemberDataExternal& a, RoomMemberDataExternal& b) { a.Swap(&b); } + inline void Swap(RoomMemberDataExternal* PROTOBUF_NONNULL other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RoomMemberDataExternal* PROTOBUF_NONNULL other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RoomMemberDataExternal* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const RoomMemberDataExternal& from); + void MergeFrom(const RoomMemberDataExternal& from) { RoomMemberDataExternal::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RoomMemberDataExternal* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "np2_structs.RoomMemberDataExternal"; } + + explicit RoomMemberDataExternal(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + RoomMemberDataExternal(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const RoomMemberDataExternal& from); + RoomMemberDataExternal( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, RoomMemberDataExternal&& from) noexcept + : RoomMemberDataExternal(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); + + public: + static constexpr auto InternalGenerateClassData_(); + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kUserInfoFieldNumber = 1, + kRoleFieldNumber = 3, + kJoinDateFieldNumber = 2, + }; + // .np2_structs.UserInfo userInfo = 1; + bool has_userinfo() const; + void clear_userinfo() ; + const ::np2_structs::UserInfo& userinfo() const; + [[nodiscard]] ::np2_structs::UserInfo* PROTOBUF_NULLABLE release_userinfo(); + ::np2_structs::UserInfo* PROTOBUF_NONNULL mutable_userinfo(); + void set_allocated_userinfo(::np2_structs::UserInfo* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_userinfo(::np2_structs::UserInfo* PROTOBUF_NULLABLE value); + ::np2_structs::UserInfo* PROTOBUF_NULLABLE unsafe_arena_release_userinfo(); + + private: + const ::np2_structs::UserInfo& _internal_userinfo() const; + ::np2_structs::UserInfo* PROTOBUF_NONNULL _internal_mutable_userinfo(); + + public: + // .np2_structs.uint8 role = 3; + bool has_role() const; + void clear_role() ; + const ::np2_structs::uint8& role() const; + [[nodiscard]] ::np2_structs::uint8* PROTOBUF_NULLABLE release_role(); + ::np2_structs::uint8* PROTOBUF_NONNULL mutable_role(); + void set_allocated_role(::np2_structs::uint8* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_role(::np2_structs::uint8* PROTOBUF_NULLABLE value); + ::np2_structs::uint8* PROTOBUF_NULLABLE unsafe_arena_release_role(); + + private: + const ::np2_structs::uint8& _internal_role() const; + ::np2_structs::uint8* PROTOBUF_NONNULL _internal_mutable_role(); + + public: + // uint64 joinDate = 2; + void clear_joindate() ; + ::uint64_t joindate() const; + void set_joindate(::uint64_t value); + + private: + ::uint64_t _internal_joindate() const; + void _internal_set_joindate(::uint64_t value); + + public: + // @@protoc_insertion_point(class_scope:np2_structs.RoomMemberDataExternal) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 3, + 2, 0, + 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const RoomMemberDataExternal& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::np2_structs::UserInfo* PROTOBUF_NULLABLE userinfo_; + ::np2_structs::uint8* PROTOBUF_NULLABLE role_; + ::uint64_t joindate_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_np2_5fstructs_2eproto; +}; + +extern const ::google::protobuf::internal::ClassDataLite<35> RoomMemberDataExternal_class_data_; +// ------------------------------------------------------------------- + class RoomGroupPasswordConfig final : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:np2_structs.RoomGroupPasswordConfig) */ { public: @@ -16603,6 +16823,191 @@ class IntSearchFilter final : public ::google::protobuf::MessageLite extern const ::google::protobuf::internal::ClassDataLite<28> IntSearchFilter_class_data_; // ------------------------------------------------------------------- +class GetRoomMemberDataExternalListResponse final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:np2_structs.GetRoomMemberDataExternalListResponse) */ { + public: + inline GetRoomMemberDataExternalListResponse() : GetRoomMemberDataExternalListResponse(nullptr) {} + ~GetRoomMemberDataExternalListResponse() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(GetRoomMemberDataExternalListResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(GetRoomMemberDataExternalListResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR GetRoomMemberDataExternalListResponse(::google::protobuf::internal::ConstantInitialized); + + inline GetRoomMemberDataExternalListResponse(const GetRoomMemberDataExternalListResponse& from) : GetRoomMemberDataExternalListResponse(nullptr, from) {} + inline GetRoomMemberDataExternalListResponse(GetRoomMemberDataExternalListResponse&& from) noexcept + : GetRoomMemberDataExternalListResponse(nullptr, ::std::move(from)) {} + inline GetRoomMemberDataExternalListResponse& operator=(const GetRoomMemberDataExternalListResponse& from) { + CopyFrom(from); + return *this; + } + inline GetRoomMemberDataExternalListResponse& operator=(GetRoomMemberDataExternalListResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString); + } + inline ::std::string* PROTOBUF_NONNULL mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::std::string>(); + } + + static const GetRoomMemberDataExternalListResponse& default_instance() { + return *reinterpret_cast( + &_GetRoomMemberDataExternalListResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 90; + friend void swap(GetRoomMemberDataExternalListResponse& a, GetRoomMemberDataExternalListResponse& b) { a.Swap(&b); } + inline void Swap(GetRoomMemberDataExternalListResponse* PROTOBUF_NONNULL other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(GetRoomMemberDataExternalListResponse* PROTOBUF_NONNULL other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + GetRoomMemberDataExternalListResponse* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const GetRoomMemberDataExternalListResponse& from); + void MergeFrom(const GetRoomMemberDataExternalListResponse& from) { GetRoomMemberDataExternalListResponse::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(GetRoomMemberDataExternalListResponse* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "np2_structs.GetRoomMemberDataExternalListResponse"; } + + explicit GetRoomMemberDataExternalListResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + GetRoomMemberDataExternalListResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const GetRoomMemberDataExternalListResponse& from); + GetRoomMemberDataExternalListResponse( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, GetRoomMemberDataExternalListResponse&& from) noexcept + : GetRoomMemberDataExternalListResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); + + public: + static constexpr auto InternalGenerateClassData_(); + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kMembersFieldNumber = 1, + }; + // repeated .np2_structs.RoomMemberDataExternal members = 1; + int members_size() const; + private: + int _internal_members_size() const; + + public: + void clear_members() ; + ::np2_structs::RoomMemberDataExternal* PROTOBUF_NONNULL mutable_members(int index); + ::google::protobuf::RepeatedPtrField<::np2_structs::RoomMemberDataExternal>* PROTOBUF_NONNULL mutable_members(); + + private: + const ::google::protobuf::RepeatedPtrField<::np2_structs::RoomMemberDataExternal>& _internal_members() const; + ::google::protobuf::RepeatedPtrField<::np2_structs::RoomMemberDataExternal>* PROTOBUF_NONNULL _internal_mutable_members(); + public: + const ::np2_structs::RoomMemberDataExternal& members(int index) const; + ::np2_structs::RoomMemberDataExternal* PROTOBUF_NONNULL add_members(); + const ::google::protobuf::RepeatedPtrField<::np2_structs::RoomMemberDataExternal>& members() const; + // @@protoc_insertion_point(class_scope:np2_structs.GetRoomMemberDataExternalListResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<0, 1, + 1, 0, + 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const GetRoomMemberDataExternalListResponse& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::RepeatedPtrField< ::np2_structs::RoomMemberDataExternal > members_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_np2_5fstructs_2eproto; +}; + +extern const ::google::protobuf::internal::ClassDataLite<50> GetRoomMemberDataExternalListResponse_class_data_; +// ------------------------------------------------------------------- + class CreateJoinRoomRequest final : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:np2_structs.CreateJoinRoomRequest) */ { public: @@ -38603,6 +39008,293 @@ MatchingSearchJoinRoomInfo::_internal_mutable_attr() { return &_impl_.attr_; } +// ------------------------------------------------------------------- + +// RoomMemberDataExternal + +// .np2_structs.UserInfo userInfo = 1; +inline bool RoomMemberDataExternal::has_userinfo() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U); + PROTOBUF_ASSUME(!value || _impl_.userinfo_ != nullptr); + return value; +} +inline void RoomMemberDataExternal::clear_userinfo() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.userinfo_ != nullptr) _impl_.userinfo_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); +} +inline const ::np2_structs::UserInfo& RoomMemberDataExternal::_internal_userinfo() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::np2_structs::UserInfo* p = _impl_.userinfo_; + return p != nullptr ? *p : reinterpret_cast(::np2_structs::_UserInfo_default_instance_); +} +inline const ::np2_structs::UserInfo& RoomMemberDataExternal::userinfo() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:np2_structs.RoomMemberDataExternal.userInfo) + return _internal_userinfo(); +} +inline void RoomMemberDataExternal::unsafe_arena_set_allocated_userinfo( + ::np2_structs::UserInfo* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.userinfo_); + } + _impl_.userinfo_ = reinterpret_cast<::np2_structs::UserInfo*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:np2_structs.RoomMemberDataExternal.userInfo) +} +inline ::np2_structs::UserInfo* PROTOBUF_NULLABLE RoomMemberDataExternal::release_userinfo() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + ::np2_structs::UserInfo* released = _impl_.userinfo_; + _impl_.userinfo_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::np2_structs::UserInfo* PROTOBUF_NULLABLE RoomMemberDataExternal::unsafe_arena_release_userinfo() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:np2_structs.RoomMemberDataExternal.userInfo) + + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + ::np2_structs::UserInfo* temp = _impl_.userinfo_; + _impl_.userinfo_ = nullptr; + return temp; +} +inline ::np2_structs::UserInfo* PROTOBUF_NONNULL RoomMemberDataExternal::_internal_mutable_userinfo() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.userinfo_ == nullptr) { + auto* p = ::google::protobuf::MessageLite::DefaultConstruct<::np2_structs::UserInfo>(GetArena()); + _impl_.userinfo_ = reinterpret_cast<::np2_structs::UserInfo*>(p); + } + return _impl_.userinfo_; +} +inline ::np2_structs::UserInfo* PROTOBUF_NONNULL RoomMemberDataExternal::mutable_userinfo() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::np2_structs::UserInfo* _msg = _internal_mutable_userinfo(); + // @@protoc_insertion_point(field_mutable:np2_structs.RoomMemberDataExternal.userInfo) + return _msg; +} +inline void RoomMemberDataExternal::set_allocated_userinfo(::np2_structs::UserInfo* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.userinfo_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = value->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } + + _impl_.userinfo_ = reinterpret_cast<::np2_structs::UserInfo*>(value); + // @@protoc_insertion_point(field_set_allocated:np2_structs.RoomMemberDataExternal.userInfo) +} + +// uint64 joinDate = 2; +inline void RoomMemberDataExternal::clear_joindate() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.joindate_ = ::uint64_t{0u}; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); +} +inline ::uint64_t RoomMemberDataExternal::joindate() const { + // @@protoc_insertion_point(field_get:np2_structs.RoomMemberDataExternal.joinDate) + return _internal_joindate(); +} +inline void RoomMemberDataExternal::set_joindate(::uint64_t value) { + _internal_set_joindate(value); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + // @@protoc_insertion_point(field_set:np2_structs.RoomMemberDataExternal.joinDate) +} +inline ::uint64_t RoomMemberDataExternal::_internal_joindate() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.joindate_; +} +inline void RoomMemberDataExternal::_internal_set_joindate(::uint64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.joindate_ = value; +} + +// .np2_structs.uint8 role = 3; +inline bool RoomMemberDataExternal::has_role() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); + PROTOBUF_ASSUME(!value || _impl_.role_ != nullptr); + return value; +} +inline void RoomMemberDataExternal::clear_role() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.role_ != nullptr) _impl_.role_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); +} +inline const ::np2_structs::uint8& RoomMemberDataExternal::_internal_role() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::np2_structs::uint8* p = _impl_.role_; + return p != nullptr ? *p : reinterpret_cast(::np2_structs::_uint8_default_instance_); +} +inline const ::np2_structs::uint8& RoomMemberDataExternal::role() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:np2_structs.RoomMemberDataExternal.role) + return _internal_role(); +} +inline void RoomMemberDataExternal::unsafe_arena_set_allocated_role( + ::np2_structs::uint8* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.role_); + } + _impl_.role_ = reinterpret_cast<::np2_structs::uint8*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:np2_structs.RoomMemberDataExternal.role) +} +inline ::np2_structs::uint8* PROTOBUF_NULLABLE RoomMemberDataExternal::release_role() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::np2_structs::uint8* released = _impl_.role_; + _impl_.role_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::np2_structs::uint8* PROTOBUF_NULLABLE RoomMemberDataExternal::unsafe_arena_release_role() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:np2_structs.RoomMemberDataExternal.role) + + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::np2_structs::uint8* temp = _impl_.role_; + _impl_.role_ = nullptr; + return temp; +} +inline ::np2_structs::uint8* PROTOBUF_NONNULL RoomMemberDataExternal::_internal_mutable_role() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.role_ == nullptr) { + auto* p = ::google::protobuf::MessageLite::DefaultConstruct<::np2_structs::uint8>(GetArena()); + _impl_.role_ = reinterpret_cast<::np2_structs::uint8*>(p); + } + return _impl_.role_; +} +inline ::np2_structs::uint8* PROTOBUF_NONNULL RoomMemberDataExternal::mutable_role() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::np2_structs::uint8* _msg = _internal_mutable_role(); + // @@protoc_insertion_point(field_mutable:np2_structs.RoomMemberDataExternal.role) + return _msg; +} +inline void RoomMemberDataExternal::set_allocated_role(::np2_structs::uint8* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.role_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = value->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } + + _impl_.role_ = reinterpret_cast<::np2_structs::uint8*>(value); + // @@protoc_insertion_point(field_set_allocated:np2_structs.RoomMemberDataExternal.role) +} + +// ------------------------------------------------------------------- + +// GetRoomMemberDataExternalListResponse + +// repeated .np2_structs.RoomMemberDataExternal members = 1; +inline int GetRoomMemberDataExternalListResponse::_internal_members_size() const { + return _internal_members().size(); +} +inline int GetRoomMemberDataExternalListResponse::members_size() const { + return _internal_members_size(); +} +inline void GetRoomMemberDataExternalListResponse::clear_members() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.members_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); +} +inline ::np2_structs::RoomMemberDataExternal* PROTOBUF_NONNULL GetRoomMemberDataExternalListResponse::mutable_members(int index) + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable:np2_structs.GetRoomMemberDataExternalListResponse.members) + return _internal_mutable_members()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField<::np2_structs::RoomMemberDataExternal>* PROTOBUF_NONNULL GetRoomMemberDataExternalListResponse::mutable_members() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); + // @@protoc_insertion_point(field_mutable_list:np2_structs.GetRoomMemberDataExternalListResponse.members) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_members(); +} +inline const ::np2_structs::RoomMemberDataExternal& GetRoomMemberDataExternalListResponse::members(int index) const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:np2_structs.GetRoomMemberDataExternalListResponse.members) + return _internal_members().Get(index); +} +inline ::np2_structs::RoomMemberDataExternal* PROTOBUF_NONNULL GetRoomMemberDataExternalListResponse::add_members() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::np2_structs::RoomMemberDataExternal* _add = + _internal_mutable_members()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); + // @@protoc_insertion_point(field_add:np2_structs.GetRoomMemberDataExternalListResponse.members) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField<::np2_structs::RoomMemberDataExternal>& GetRoomMemberDataExternalListResponse::members() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:np2_structs.GetRoomMemberDataExternalListResponse.members) + return _internal_members(); +} +inline const ::google::protobuf::RepeatedPtrField<::np2_structs::RoomMemberDataExternal>& +GetRoomMemberDataExternalListResponse::_internal_members() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.members_; +} +inline ::google::protobuf::RepeatedPtrField<::np2_structs::RoomMemberDataExternal>* PROTOBUF_NONNULL +GetRoomMemberDataExternalListResponse::_internal_mutable_members() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.members_; +} + #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ diff --git a/rpcs3/Emu/NP/generated/np2_structs.proto b/rpcs3/Emu/NP/generated/np2_structs.proto index 46628781fb..fcb5c7304e 100644 --- a/rpcs3/Emu/NP/generated/np2_structs.proto +++ b/rpcs3/Emu/NP/generated/np2_structs.proto @@ -606,3 +606,14 @@ message MatchingSearchJoinRoomInfo { MatchingRoomStatus room = 1; repeated MatchingAttr attr = 2; } + +message RoomMemberDataExternal { + UserInfo userInfo = 1; + uint64 joinDate = 2; + uint8 role = 3; +} + +message GetRoomMemberDataExternalListResponse +{ + repeated RoomMemberDataExternal members = 1; +} diff --git a/rpcs3/Emu/NP/np_handler.cpp b/rpcs3/Emu/NP/np_handler.cpp index bc65f545b3..c4db3350c0 100644 --- a/rpcs3/Emu/NP/np_handler.cpp +++ b/rpcs3/Emu/NP/np_handler.cpp @@ -1127,6 +1127,7 @@ namespace np case rpcn::CommandType::LeaveRoom: reply_leave_room(req_id, error, reply_data); break; case rpcn::CommandType::SearchRoom: reply_search_room(req_id, error, reply_data); break; case rpcn::CommandType::GetRoomDataExternalList: reply_get_roomdata_external_list(req_id, error, reply_data); break; + case rpcn::CommandType::GetRoomMemberDataExternalList: reply_get_room_member_data_external_list(req_id, error, reply_data); break; case rpcn::CommandType::SetRoomDataExternal: reply_set_roomdata_external(req_id, error); break; case rpcn::CommandType::GetRoomDataInternal: reply_get_roomdata_internal(req_id, error, reply_data); break; case rpcn::CommandType::SetRoomDataInternal: reply_set_roomdata_internal(req_id, error); break; diff --git a/rpcs3/Emu/NP/np_handler.h b/rpcs3/Emu/NP/np_handler.h index 51d510b854..9c02007a9c 100644 --- a/rpcs3/Emu/NP/np_handler.h +++ b/rpcs3/Emu/NP/np_handler.h @@ -177,6 +177,7 @@ namespace np u32 leave_room(SceNpMatching2ContextId ctx_id, vm::cptr optParam, const SceNpMatching2LeaveRoomRequest* req); u32 search_room(SceNpMatching2ContextId ctx_id, vm::cptr optParam, const SceNpMatching2SearchRoomRequest* req); u32 get_roomdata_external_list(SceNpMatching2ContextId ctx_id, vm::cptr optParam, const SceNpMatching2GetRoomDataExternalListRequest* req); + u32 get_room_member_data_external_list(SceNpMatching2ContextId ctx_id, vm::cptr optParam, const SceNpMatching2GetRoomMemberDataExternalListRequest* req); u32 set_roomdata_external(SceNpMatching2ContextId ctx_id, vm::cptr optParam, const SceNpMatching2SetRoomDataExternalRequest* req); u32 get_roomdata_internal(SceNpMatching2ContextId ctx_id, vm::cptr optParam, const SceNpMatching2GetRoomDataInternalRequest* req); u32 set_roomdata_internal(SceNpMatching2ContextId ctx_id, vm::cptr optParam, const SceNpMatching2SetRoomDataInternalRequest* req); @@ -323,6 +324,7 @@ namespace np void reply_leave_room(u32 req_id, rpcn::ErrorType error, vec_stream& reply); void reply_search_room(u32 req_id, rpcn::ErrorType error, vec_stream& reply); void reply_get_roomdata_external_list(u32 req_id, rpcn::ErrorType error, vec_stream& reply); + void reply_get_room_member_data_external_list(u32 req_id, rpcn::ErrorType error, vec_stream& reply); void reply_set_roomdata_external(u32 req_id, rpcn::ErrorType error); void reply_get_roomdata_internal(u32 req_id, rpcn::ErrorType error, vec_stream& reply); void reply_set_roomdata_internal(u32 req_id, rpcn::ErrorType error); diff --git a/rpcs3/Emu/NP/np_requests.cpp b/rpcs3/Emu/NP/np_requests.cpp index 0ee7d1d0fc..20199889dc 100644 --- a/rpcs3/Emu/NP/np_requests.cpp +++ b/rpcs3/Emu/NP/np_requests.cpp @@ -445,6 +445,50 @@ namespace np cb_info_opt->queue_callback(req_id, event_key, 0, edata.size()); } + u32 np_handler::get_room_member_data_external_list(SceNpMatching2ContextId ctx_id, vm::cptr optParam, const SceNpMatching2GetRoomMemberDataExternalListRequest* req) + { + const u32 req_id = generate_callback_info(ctx_id, optParam, SCE_NP_MATCHING2_REQUEST_EVENT_GetRoomDataExternalList, true); + + if (!get_rpcn()->get_room_member_data_external_list(req_id, get_match2_context(ctx_id)->communicationId, req->roomId)) + { + rpcn_log.error("Disconnecting from RPCN!"); + is_psn_active = false; + } + + return req_id; + } + + void np_handler::reply_get_room_member_data_external_list(u32 req_id, rpcn::ErrorType error, vec_stream& reply) + { + auto cb_info_opt = take_pending_request(req_id); + + if (!cb_info_opt) + return; + + ensure(error == rpcn::ErrorType::NoError, "Unexpected error in GetRoomMemberDataExternalList reply"); + + if (error == rpcn::ErrorType::RoomMissing) + { + cb_info_opt->queue_callback(req_id, 0, SCE_NP_MATCHING2_SERVER_ERROR_NO_SUCH_ROOM, 0); + return; + } + + const auto resp = reply.get_protobuf(); + ensure(!reply.is_error(), "Malformed reply to GetRoomMemberDataExternalList command"); + + const u32 event_key = get_event_key(); + auto [include_onlinename, include_avatarurl] = get_match2_context_options(cb_info_opt->ctx_id); + + auto& edata = allocate_req_result(event_key, SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_GetRoomMemberDataExternalList, sizeof(SceNpMatching2GetRoomMemberDataExternalListResponse)); + auto* sce_get_room_member_ext_resp = reinterpret_cast(edata.data()); + GetRoomMemberDataExternalListResponse_to_SceNpMatching2GetRoomMemberDataExternalListResponse(edata, *resp, sce_get_room_member_ext_resp, include_onlinename, include_avatarurl); + np_memory.shrink_allocation(edata.addr(), edata.size()); + + extra_nps::print_SceNpMatching2GetRoomMemberDataExternalListResponse(sce_get_room_member_ext_resp); + + cb_info_opt->queue_callback(req_id, event_key, 0, edata.size()); + } + u32 np_handler::set_roomdata_external(SceNpMatching2ContextId ctx_id, vm::cptr optParam, const SceNpMatching2SetRoomDataExternalRequest* req) { const u32 req_id = generate_callback_info(ctx_id, optParam, SCE_NP_MATCHING2_REQUEST_EVENT_SetRoomDataExternal, false); diff --git a/rpcs3/Emu/NP/np_structs_extra.cpp b/rpcs3/Emu/NP/np_structs_extra.cpp index 52f394ff2e..58770c450f 100644 --- a/rpcs3/Emu/NP/np_structs_extra.cpp +++ b/rpcs3/Emu/NP/np_structs_extra.cpp @@ -195,6 +195,15 @@ namespace extra_nps } } + void print_SceNpMatching2RoomMemberDataExternal(const SceNpMatching2RoomMemberDataExternal* member) + { + sceNp2.warning("SceNpMatching2RoomMemberDataExternal:"); + sceNp2.warning("next: *0x%x", member->next); + print_SceNpUserInfo2(&member->userInfo); + sceNp2.warning("joinDate: %lld", member->joinDate.tick); + sceNp2.warning("role: %d", member->role); + } + void print_SceNpMatching2RoomMemberDataInternal(const SceNpMatching2RoomMemberDataInternal* member) { sceNp2.warning("SceNpMatching2RoomMemberDataInternal:"); @@ -397,6 +406,21 @@ namespace extra_nps } } + void print_SceNpMatching2GetRoomMemberDataExternalListResponse(const SceNpMatching2GetRoomMemberDataExternalListResponse* resp) + { + sceNp2.warning("SceNpMatching2GetRoomMemberDataExternalListResponse:"); + sceNp2.warning("roomMemberDataExternalNum: %d", resp->roomMemberDataExternalNum); + + vm::bptr cur_member = resp->roomMemberDataExternal; + + for (u32 i = 0; i < resp->roomMemberDataExternalNum && cur_member; i++) + { + sceNp2.warning("roomMemberDataExternal[%d]:", i); + print_SceNpMatching2RoomMemberDataExternal(cur_member.get_ptr()); + cur_member = cur_member->next; + } + } + void print_SceNpMatching2GetLobbyInfoListRequest(const SceNpMatching2GetLobbyInfoListRequest* resp) { sceNp2.warning("SceNpMatching2GetLobbyInfoListRequest:"); diff --git a/rpcs3/Emu/NP/np_structs_extra.h b/rpcs3/Emu/NP/np_structs_extra.h index 1c722a0cf2..45f4cffc4a 100644 --- a/rpcs3/Emu/NP/np_structs_extra.h +++ b/rpcs3/Emu/NP/np_structs_extra.h @@ -11,6 +11,7 @@ namespace extra_nps void print_SceNpMatching2RangeFilter(const SceNpMatching2RangeFilter* filt); void print_SceNpMatching2RoomDataInternal(const SceNpMatching2RoomDataInternal* room); void print_SceNpMatching2RoomDataExternal(const SceNpMatching2RoomDataExternal* room); + void print_SceNpMatching2RoomMemberDataExternal(const SceNpMatching2RoomMemberDataExternal* room); void print_SceNpMatching2RoomMemberDataInternal(const SceNpMatching2RoomMemberDataInternal* member); void print_SceNpMatching2CreateJoinRoomRequest(const SceNpMatching2CreateJoinRoomRequest* req); @@ -24,6 +25,7 @@ namespace extra_nps void print_SceNpMatching2SetRoomMemberDataInternalRequest(const SceNpMatching2SetRoomMemberDataInternalRequest* req); void print_SceNpMatching2GetRoomDataExternalListRequest(const SceNpMatching2GetRoomDataExternalListRequest* req); void print_SceNpMatching2GetRoomDataExternalListResponse(const SceNpMatching2GetRoomDataExternalListResponse* resp); + void print_SceNpMatching2GetRoomMemberDataExternalListResponse(const SceNpMatching2GetRoomMemberDataExternalListResponse* resp); void print_SceNpMatching2GetLobbyInfoListRequest(const SceNpMatching2GetLobbyInfoListRequest* resp); diff --git a/rpcs3/Emu/NP/pb_helpers.cpp b/rpcs3/Emu/NP/pb_helpers.cpp index e82fc2ec0a..41b0ca4579 100644 --- a/rpcs3/Emu/NP/pb_helpers.cpp +++ b/rpcs3/Emu/NP/pb_helpers.cpp @@ -171,6 +171,15 @@ namespace np } } + void RoomMemberDataExternal_to_SceNpMatching2RoomMemberDataExternal(event_data& edata, const np2_structs::RoomMemberDataExternal& member, SceNpMatching2RoomMemberDataExternal* member_info, bool include_onlinename, bool include_avatarurl) + { + ensure(member.has_userinfo()); + + UserInfo_to_SceNpUserInfo2(edata, member.userinfo(), &member_info->userInfo, include_onlinename, include_avatarurl); + member_info->joinDate.tick = member.joindate(); + member_info->role = member.role().value(); + } + void SearchRoomResponse_to_SceNpMatching2SearchRoomResponse(event_data& edata, const np2_structs::SearchRoomResponse& resp, SceNpMatching2SearchRoomResponse* search_resp) { search_resp->range.size = resp.rooms_size(); @@ -181,8 +190,7 @@ namespace np for (int i = 0; i < resp.rooms_size(); i++) { const auto& pb_room = resp.rooms(i); - SceNpMatching2RoomDataExternal* cur_room; - cur_room = edata.allocate(sizeof(SceNpMatching2RoomDataExternal), (i > 0) ? prev_room->next : search_resp->roomDataExternal); + SceNpMatching2RoomDataExternal* cur_room = edata.allocate(sizeof(SceNpMatching2RoomDataExternal), (i > 0) ? prev_room->next : search_resp->roomDataExternal); RoomDataExternal_to_SceNpMatching2RoomDataExternal(edata, pb_room, cur_room, true, true); prev_room = cur_room; } @@ -196,15 +204,28 @@ namespace np for (int i = 0; i < resp.rooms_size(); i++) { const auto& pb_room = resp.rooms(i); - SceNpMatching2RoomDataExternal* cur_room; - - cur_room = edata.allocate(sizeof(SceNpMatching2RoomDataExternal), (i > 0) ? prev_room->next : get_resp->roomDataExternal); + SceNpMatching2RoomDataExternal* cur_room = edata.allocate(sizeof(SceNpMatching2RoomDataExternal), (i > 0) ? prev_room->next : get_resp->roomDataExternal); RoomDataExternal_to_SceNpMatching2RoomDataExternal(edata, pb_room, cur_room, include_onlinename, include_avatarurl); prev_room = cur_room; } } + void GetRoomMemberDataExternalListResponse_to_SceNpMatching2GetRoomMemberDataExternalListResponse(event_data& edata, const np2_structs::GetRoomMemberDataExternalListResponse& resp, SceNpMatching2GetRoomMemberDataExternalListResponse* get_resp, bool include_onlinename, bool include_avatarurl) + { + get_resp->roomMemberDataExternalNum = resp.members_size(); + + SceNpMatching2RoomMemberDataExternal* prev_member = nullptr; + for (int i = 0; i < resp.members_size(); i++) + { + const auto& pb_member = resp.members(i); + SceNpMatching2RoomMemberDataExternal* cur_member = edata.allocate(sizeof(SceNpMatching2RoomMemberDataExternal), (i > 0) ? prev_member->next : get_resp->roomMemberDataExternal); + + RoomMemberDataExternal_to_SceNpMatching2RoomMemberDataExternal(edata, pb_member, cur_member, include_onlinename, include_avatarurl); + prev_member = cur_member; + } + } + u16 RoomDataInternal_to_SceNpMatching2RoomDataInternal(event_data& edata, const np2_structs::RoomDataInternal& resp, SceNpMatching2RoomDataInternal* room_info, const SceNpId& npid, bool include_onlinename, bool include_avatarurl) { u16 member_id = 0; diff --git a/rpcs3/Emu/NP/pb_helpers.h b/rpcs3/Emu/NP/pb_helpers.h index c7482d7bc4..dc869210e7 100644 --- a/rpcs3/Emu/NP/pb_helpers.h +++ b/rpcs3/Emu/NP/pb_helpers.h @@ -16,8 +16,10 @@ namespace np void UserInfo_to_SceNpUserInfo(const np2_structs::UserInfo& user, SceNpUserInfo* user_info); void UserInfo_to_SceNpUserInfo2(event_data& edata, const np2_structs::UserInfo& user, SceNpUserInfo2* user_info, bool include_onlinename, bool include_avatarurl); void RoomDataExternal_to_SceNpMatching2RoomDataExternal(event_data& edata, const np2_structs::RoomDataExternal& room, SceNpMatching2RoomDataExternal* room_info, bool include_onlinename, bool include_avatarurl); + void RoomMemberDataExternal_to_SceNpMatching2RoomMemberDataExternal(event_data& edata, const np2_structs::RoomMemberDataExternal& member, SceNpMatching2RoomMemberDataExternal* member_info, bool include_onlinename, bool include_avatarurl); void SearchRoomResponse_to_SceNpMatching2SearchRoomResponse(event_data& edata, const np2_structs::SearchRoomResponse& resp, SceNpMatching2SearchRoomResponse* search_resp); void GetRoomDataExternalListResponse_to_SceNpMatching2GetRoomDataExternalListResponse(event_data& edata, const np2_structs::GetRoomDataExternalListResponse& resp, SceNpMatching2GetRoomDataExternalListResponse* get_resp, bool include_onlinename, bool include_avatarurl); + void GetRoomMemberDataExternalListResponse_to_SceNpMatching2GetRoomMemberDataExternalListResponse(event_data& edata, const np2_structs::GetRoomMemberDataExternalListResponse& resp, SceNpMatching2GetRoomMemberDataExternalListResponse* get_resp, bool include_onlinename, bool include_avatarurl); u16 RoomDataInternal_to_SceNpMatching2RoomDataInternal(event_data& edata, const np2_structs::RoomDataInternal& resp, SceNpMatching2RoomDataInternal* room_resp, const SceNpId& npid, bool include_onlinename, bool include_avatarurl); void RoomMemberDataInternal_to_SceNpMatching2RoomMemberDataInternal(event_data& edata, const np2_structs::RoomMemberDataInternal& member_data, const SceNpMatching2RoomDataInternal* room_info, SceNpMatching2RoomMemberDataInternal* sce_member_data, bool include_onlinename, bool include_avatarurl); void RoomMemberUpdateInfo_to_SceNpMatching2RoomMemberUpdateInfo(event_data& edata, const np2_structs::RoomMemberUpdateInfo& resp, SceNpMatching2RoomMemberUpdateInfo* room_info, bool include_onlinename, bool include_avatarurl); diff --git a/rpcs3/Emu/NP/rpcn_client.cpp b/rpcs3/Emu/NP/rpcn_client.cpp index cce4fa397b..c1126b8698 100644 --- a/rpcs3/Emu/NP/rpcn_client.cpp +++ b/rpcs3/Emu/NP/rpcn_client.cpp @@ -117,6 +117,7 @@ void fmt_class_string::format(std::string& out, u64 arg) case rpcn::CommandType::LeaveRoom: return "LeaveRoom"; case rpcn::CommandType::SearchRoom: return "SearchRoom"; case rpcn::CommandType::GetRoomDataExternalList: return "GetRoomDataExternalList"; + case rpcn::CommandType::GetRoomMemberDataExternalList: return "GetRoomMemberDataExternalList"; case rpcn::CommandType::SetRoomDataExternal: return "SetRoomDataExternal"; case rpcn::CommandType::GetRoomDataInternal: return "GetRoomDataInternal"; case rpcn::CommandType::SetRoomDataInternal: return "SetRoomDataInternal"; @@ -1915,6 +1916,16 @@ namespace rpcn return forge_request_with_com_id(serialized, communication_id, CommandType::GetRoomDataExternalList, req_id); } + bool rpcn_client::get_room_member_data_external_list(u32 req_id, const SceNpCommunicationId& communication_id, u64 room_id) + { + std::vector data(COMMUNICATION_ID_SIZE + sizeof(u64)); + + rpcn_client::write_communication_id(communication_id, data); + write_to_ptr>(data, COMMUNICATION_ID_SIZE, room_id); + + return forge_send(CommandType::GetRoomMemberDataExternalList, req_id, data); + } + bool rpcn_client::set_roomdata_external(u32 req_id, const SceNpCommunicationId& communication_id, const SceNpMatching2SetRoomDataExternalRequest* req) { np2_structs::SetRoomDataExternalRequest pb_req; diff --git a/rpcs3/Emu/NP/rpcn_client.h b/rpcs3/Emu/NP/rpcn_client.h index e3c3f47ba9..035dc9cf3c 100644 --- a/rpcs3/Emu/NP/rpcn_client.h +++ b/rpcs3/Emu/NP/rpcn_client.h @@ -329,6 +329,7 @@ namespace rpcn bool leave_room(u32 req_id, const SceNpCommunicationId& communication_id, const SceNpMatching2LeaveRoomRequest* req); bool search_room(u32 req_id, const SceNpCommunicationId& communication_id, const SceNpMatching2SearchRoomRequest* req); bool get_roomdata_external_list(u32 req_id, const SceNpCommunicationId& communication_id, const SceNpMatching2GetRoomDataExternalListRequest* req); + bool get_room_member_data_external_list(u32 req_id, const SceNpCommunicationId& communication_id, u64 room_id); bool set_roomdata_external(u32 req_id, const SceNpCommunicationId& communication_id, const SceNpMatching2SetRoomDataExternalRequest* req); bool get_roomdata_internal(u32 req_id, const SceNpCommunicationId& communication_id, const SceNpMatching2GetRoomDataInternalRequest* req); bool set_roomdata_internal(u32 req_id, const SceNpCommunicationId& communication_id, const SceNpMatching2SetRoomDataInternalRequest* req); diff --git a/rpcs3/Emu/NP/rpcn_types.h b/rpcs3/Emu/NP/rpcn_types.h index 15fba827d5..28500462e6 100644 --- a/rpcs3/Emu/NP/rpcn_types.h +++ b/rpcs3/Emu/NP/rpcn_types.h @@ -68,6 +68,7 @@ namespace rpcn GetRoomInfoGUI, QuickMatchGUI, SearchJoinRoomGUI, + GetRoomMemberDataExternalList, }; enum class NotificationType : u16