R5Reloaded/r5sdk
1
0
Fork 0
mirror of https://github.com/Mauler125/r5sdk.git synced 2025-02-09 19:15:03 +01:00
Code Issues Packages Projects Releases Wiki Activity

Update protobuf to latest

Browse Source 
Updated to v21.12.
This commit is contained in:
Kawe Mazidjatari 2023-01-26 03:15:10 +01:00
parent c49209bd1e
commit 188cbf8359
435 changed files with 30503 additions and 28322 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

205
r5dev/protoc/cl_rcon.pb.cc
View File

@ -13,23 +13,28 @@
#include <thirdparty/protobuf/port_def.inc>
PROTOBUF_PRAGMA_INIT_SEG
namespace _pb = ::PROTOBUF_NAMESPACE_ID;
namespace _pbi = _pb::internal;
namespace cl_rcon {
constexpr request::request(
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
: requestbuf_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
, requestval_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
, requestid_(0)
, requesttype_(0)
{}
PROTOBUF_CONSTEXPR request::request(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._has_bits_)*/{}
, /*decltype(_impl_._cached_size_)*/{}
, /*decltype(_impl_.requestbuf_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
, /*decltype(_impl_.requestval_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
, /*decltype(_impl_.requestid_)*/0
, /*decltype(_impl_.requesttype_)*/0} {}
struct requestDefaultTypeInternal {
constexpr requestDefaultTypeInternal()
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
PROTOBUF_CONSTEXPR requestDefaultTypeInternal()
: _instance(::_pbi::ConstantInitialized{}) {}
~requestDefaultTypeInternal() {}
union {
request _instance;
};
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT requestDefaultTypeInternal _request_default_instance_;
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 requestDefaultTypeInternal _request_default_instance_;
} // namespace cl_rcon
namespace cl_rcon {
bool request_t_IsValid(int value) {
@ -104,7 +109,7 @@ bool request_t_Parse(
class request::_Internal {
public:
using HasBits = decltype(std::declval<request>()._has_bits_);
using HasBits = decltype(std::declval<request>()._impl_._has_bits_);
static void set_has_requestid(HasBits* has_bits) {
(*has_bits)[0] |= 4u;
}
@ -122,74 +127,82 @@ class request::_Internal {
request::request(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned)
: ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
SharedCtor();
if (!is_message_owned) {
RegisterArenaDtor(arena);
}
SharedCtor(arena, is_message_owned);
// @@protoc_insertion_point(arena_constructor:cl_rcon.request)
}
request::request(const request& from)
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
_has_bits_(from._has_bits_) {
: ::PROTOBUF_NAMESPACE_ID::MessageLite() {
request* const _this = this; (void)_this;
new (&_impl_) Impl_{
decltype(_impl_._has_bits_){from._impl_._has_bits_}
, /*decltype(_impl_._cached_size_)*/{}
, decltype(_impl_.requestbuf_){}
, decltype(_impl_.requestval_){}
, decltype(_impl_.requestid_){}
, decltype(_impl_.requesttype_){}};
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
requestbuf_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
_impl_.requestbuf_.InitDefault();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
requestbuf_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
_impl_.requestbuf_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (from._internal_has_requestbuf()) {
requestbuf_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_requestbuf(),
GetArenaForAllocation());
_this->_impl_.requestbuf_.Set(from._internal_requestbuf(),
_this->GetArenaForAllocation());
}
requestval_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
_impl_.requestval_.InitDefault();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
requestval_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
_impl_.requestval_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (from._internal_has_requestval()) {
requestval_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_requestval(),
GetArenaForAllocation());
_this->_impl_.requestval_.Set(from._internal_requestval(),
_this->GetArenaForAllocation());
}
::memcpy(&requestid_, &from.requestid_,
static_cast<size_t>(reinterpret_cast<char*>(&requesttype_) -
reinterpret_cast<char*>(&requestid_)) + sizeof(requesttype_));
::memcpy(&_impl_.requestid_, &from._impl_.requestid_,
static_cast<size_t>(reinterpret_cast<char*>(&_impl_.requesttype_) -
reinterpret_cast<char*>(&_impl_.requestid_)) + sizeof(_impl_.requesttype_));
// @@protoc_insertion_point(copy_constructor:cl_rcon.request)
}
inline void request::SharedCtor() {
requestbuf_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
requestbuf_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
requestval_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
requestval_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
reinterpret_cast<char*>(&requestid_) - reinterpret_cast<char*>(this)),
0, static_cast<size_t>(reinterpret_cast<char*>(&requesttype_) -
reinterpret_cast<char*>(&requestid_)) + sizeof(requesttype_));
inline void request::SharedCtor(
::_pb::Arena* arena, bool is_message_owned) {
(void)arena;
(void)is_message_owned;
new (&_impl_) Impl_{
decltype(_impl_._has_bits_){}
, /*decltype(_impl_._cached_size_)*/{}
, decltype(_impl_.requestbuf_){}
, decltype(_impl_.requestval_){}
, decltype(_impl_.requestid_){0}
, decltype(_impl_.requesttype_){0}
};
_impl_.requestbuf_.InitDefault();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
_impl_.requestbuf_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
_impl_.requestval_.InitDefault();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
_impl_.requestval_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}
request::~request() {
// @@protoc_insertion_point(destructor:cl_rcon.request)
if (GetArenaForAllocation() != nullptr) return;
if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
(void)arena;
return;
}
SharedDtor();
_internal_metadata_.Delete<std::string>();
}
inline void request::SharedDtor() {
GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
requestbuf_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
requestval_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
_impl_.requestbuf_.Destroy();
_impl_.requestval_.Destroy();
}
void request::ArenaDtor(void* object) {
request* _this = reinterpret_cast< request* >(object);
(void)_this;
}
void request::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void request::SetCachedSize(int size) const {
_cached_size_.Set(size);
_impl_._cached_size_.Set(size);
}
void request::Clear() {
@ -198,36 +211,36 @@ void request::Clear() {
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
cached_has_bits = _impl_._has_bits_[0];
if (cached_has_bits & 0x00000003u) {
if (cached_has_bits & 0x00000001u) {
requestbuf_.ClearNonDefaultToEmpty();
_impl_.requestbuf_.ClearNonDefaultToEmpty();
}
if (cached_has_bits & 0x00000002u) {
requestval_.ClearNonDefaultToEmpty();
_impl_.requestval_.ClearNonDefaultToEmpty();
}
}
if (cached_has_bits & 0x0000000cu) {
::memset(&requestid_, 0, static_cast<size_t>(
reinterpret_cast<char*>(&requesttype_) -
reinterpret_cast<char*>(&requestid_)) + sizeof(requesttype_));
::memset(&_impl_.requestid_, 0, static_cast<size_t>(
reinterpret_cast<char*>(&_impl_.requesttype_) -
reinterpret_cast<char*>(&_impl_.requestid_)) + sizeof(_impl_.requesttype_));
}
_has_bits_.Clear();
_impl_._has_bits_.Clear();
_internal_metadata_.Clear<std::string>();
}
const char* request::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
const char* request::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
_Internal::HasBits has_bits{};
while (!ctx->Done(&ptr)) {
uint32_t tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
ptr = ::_pbi::ReadTag(ptr, &tag);
switch (tag >> 3) {
// optional int32 requestID = 1;
case 1:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
_Internal::set_has_requestid(&has_bits);
requestid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
_impl_.requestid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
CHK_(ptr);
} else
goto handle_unusual;
@ -245,9 +258,9 @@ const char* request::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in
case 3:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
auto str = _internal_mutable_requestbuf();
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
CHK_(ptr);
CHK_(::_pbi::VerifyUTF8(str, nullptr));
} else
goto handle_unusual;
continue;
@ -255,9 +268,9 @@ const char* request::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in
case 4:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
auto str = _internal_mutable_requestval();
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
CHK_(ptr);
CHK_(::_pbi::VerifyUTF8(str, nullptr));
} else
goto handle_unusual;
continue;
@ -277,7 +290,7 @@ const char* request::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in
CHK_(ptr != nullptr);
} // while
message_done:
_has_bits_.Or(has_bits);
_impl_._has_bits_.Or(has_bits);
return ptr;
failure:
ptr = nullptr;
@ -294,13 +307,13 @@ uint8_t* request::_InternalSerialize(
// optional int32 requestID = 1;
if (_internal_has_requestid()) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_requestid(), target);
target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_requestid(), target);
}
// optional .cl_rcon.request_t requestType = 2;
if (_internal_has_requesttype()) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
target = ::_pbi::WireFormatLite::WriteEnumToArray(
2, this->_internal_requesttype(), target);
}
@ -340,7 +353,7 @@ size_t request::ByteSizeLong() const {
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
cached_has_bits = _impl_._has_bits_[0];
if (cached_has_bits & 0x0000000fu) {
// optional string requestBuf = 3;
if (cached_has_bits & 0x00000001u) {
@ -358,53 +371,54 @@ size_t request::ByteSizeLong() const {
// optional int32 requestID = 1;
if (cached_has_bits & 0x00000004u) {
total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_requestid());
total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_requestid());
}
// optional .cl_rcon.request_t requestType = 2;
if (cached_has_bits & 0x00000008u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_requesttype());
::_pbi::WireFormatLite::EnumSize(this->_internal_requesttype());
}
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
}
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
int cached_size = ::_pbi::ToCachedSize(total_size);
SetCachedSize(cached_size);
return total_size;
}
void request::CheckTypeAndMergeFrom(
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const request*>(
MergeFrom(*::_pbi::DownCast<const request*>(
&from));
}
void request::MergeFrom(const request& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:cl_rcon.request)
GOOGLE_DCHECK_NE(&from, this);
request* const _this = this;
// @@protoc_insertion_point(class_specific_merge_from_start:cl_rcon.request)
GOOGLE_DCHECK_NE(&from, _this);
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
cached_has_bits = from._has_bits_[0];
cached_has_bits = from._impl_._has_bits_[0];
if (cached_has_bits & 0x0000000fu) {
if (cached_has_bits & 0x00000001u) {
_internal_set_requestbuf(from._internal_requestbuf());
_this->_internal_set_requestbuf(from._internal_requestbuf());
}
if (cached_has_bits & 0x00000002u) {
_internal_set_requestval(from._internal_requestval());
_this->_internal_set_requestval(from._internal_requestval());
}
if (cached_has_bits & 0x00000004u) {
requestid_ = from.requestid_;
_this->_impl_.requestid_ = from._impl_.requestid_;
}
if (cached_has_bits & 0x00000008u) {
requesttype_ = from.requesttype_;
_this->_impl_.requesttype_ = from._impl_.requesttype_;
}
_has_bits_[0] |= cached_has_bits;
_this->_impl_._has_bits_[0] |= cached_has_bits;
}
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
_this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}
void request::CopyFrom(const request& from) {
@ -423,23 +437,21 @@ void request::InternalSwap(request* other) {
auto* lhs_arena = GetArenaForAllocation();
auto* rhs_arena = other->GetArenaForAllocation();
_internal_metadata_.InternalSwap(&other->_internal_metadata_);
swap(_has_bits_[0], other->_has_bits_[0]);
swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
&requestbuf_, lhs_arena,
&other->requestbuf_, rhs_arena
&_impl_.requestbuf_, lhs_arena,
&other->_impl_.requestbuf_, rhs_arena
);
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
&requestval_, lhs_arena,
&other->requestval_, rhs_arena
&_impl_.requestval_, lhs_arena,
&other->_impl_.requestval_, rhs_arena
);
::PROTOBUF_NAMESPACE_ID::internal::memswap<
PROTOBUF_FIELD_OFFSET(request, requesttype_)
+ sizeof(request::requesttype_)
- PROTOBUF_FIELD_OFFSET(request, requestid_)>(
reinterpret_cast<char*>(&requestid_),
reinterpret_cast<char*>(&other->requestid_));
PROTOBUF_FIELD_OFFSET(request, _impl_.requesttype_)
+ sizeof(request::_impl_.requesttype_)
- PROTOBUF_FIELD_OFFSET(request, _impl_.requestid_)>(
reinterpret_cast<char*>(&_impl_.requestid_),
reinterpret_cast<char*>(&other->_impl_.requestid_));
}
std::string request::GetTypeName() const {
@ -450,7 +462,8 @@ std::string request::GetTypeName() const {
// @@protoc_insertion_point(namespace_scope)
} // namespace cl_rcon
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::cl_rcon::request* Arena::CreateMaybeMessage< ::cl_rcon::request >(Arena* arena) {
template<> PROTOBUF_NOINLINE ::cl_rcon::request*
Arena::CreateMaybeMessage< ::cl_rcon::request >(Arena* arena) {
return Arena::CreateMessageInternal< ::cl_rcon::request >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

139
r5dev/protoc/cl_rcon.pb.h
View File

@ -8,12 +8,12 @@
#include <string>
#include <thirdparty/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3019000
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3019004 < PROTOBUF_MIN_PROTOC_VERSION
#if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
@ -23,7 +23,6 @@
#include <thirdparty/protobuf/io/coded_stream.h>
#include <thirdparty/protobuf/arena.h>
#include <thirdparty/protobuf/arenastring.h>
#include <thirdparty/protobuf/generated_message_table_driven.h>
#include <thirdparty/protobuf/generated_message_util.h>
#include <thirdparty/protobuf/metadata_lite.h>
#include <thirdparty/protobuf/message_lite.h>
@ -41,14 +40,6 @@ PROTOBUF_NAMESPACE_CLOSE
// Internal implementation detail -- do not use these members.
struct TableStruct_cl_5frcon_2eproto {
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
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[1]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
static const uint32_t offsets[];
};
namespace cl_rcon {
@ -93,7 +84,7 @@ class request final :
public:
inline request() : request(nullptr) {}
~request() override;
explicit constexpr request(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
explicit PROTOBUF_CONSTEXPR request(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
request(const request& from);
request(request&& from) noexcept
@ -166,10 +157,10 @@ class request final :
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor();
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(request* other);
@ -182,9 +173,6 @@ class request final :
protected:
explicit request(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
@ -268,12 +256,15 @@ class request final :
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr requestbuf_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr requestval_;
int32_t requestid_;
int requesttype_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr requestbuf_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr requestval_;
int32_t requestid_;
int requesttype_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_cl_5frcon_2eproto;
};
// ===================================================================
@ -289,26 +280,26 @@ class request final :
// optional int32 requestID = 1;
inline bool request::_internal_has_requestid() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool request::has_requestid() const {
return _internal_has_requestid();
}
inline void request::clear_requestid() {
requestid_ = 0;
_has_bits_[0] &= ~0x00000004u;
_impl_.requestid_ = 0;
_impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t request::_internal_requestid() const {
return requestid_;
return _impl_.requestid_;
}
inline int32_t request::requestid() const {
// @@protoc_insertion_point(field_get:cl_rcon.request.requestID)
return _internal_requestid();
}
inline void request::_internal_set_requestid(int32_t value) {
_has_bits_[0] |= 0x00000004u;
requestid_ = value;
_impl_._has_bits_[0] |= 0x00000004u;
_impl_.requestid_ = value;
}
inline void request::set_requestid(int32_t value) {
_internal_set_requestid(value);
@ -317,26 +308,26 @@ inline void request::set_requestid(int32_t value) {
// optional .cl_rcon.request_t requestType = 2;
inline bool request::_internal_has_requesttype() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool request::has_requesttype() const {
return _internal_has_requesttype();
}
inline void request::clear_requesttype() {
requesttype_ = 0;
_has_bits_[0] &= ~0x00000008u;
_impl_.requesttype_ = 0;
_impl_._has_bits_[0] &= ~0x00000008u;
}
inline ::cl_rcon::request_t request::_internal_requesttype() const {
return static_cast< ::cl_rcon::request_t >(requesttype_);
return static_cast< ::cl_rcon::request_t >(_impl_.requesttype_);
}
inline ::cl_rcon::request_t request::requesttype() const {
// @@protoc_insertion_point(field_get:cl_rcon.request.requestType)
return _internal_requesttype();
}
inline void request::_internal_set_requesttype(::cl_rcon::request_t value) {
_has_bits_[0] |= 0x00000008u;
requesttype_ = value;
_impl_._has_bits_[0] |= 0x00000008u;
_impl_.requesttype_ = value;
}
inline void request::set_requesttype(::cl_rcon::request_t value) {
_internal_set_requesttype(value);
@ -345,15 +336,15 @@ inline void request::set_requesttype(::cl_rcon::request_t value) {
// optional string requestBuf = 3;
inline bool request::_internal_has_requestbuf() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool request::has_requestbuf() const {
return _internal_has_requestbuf();
}
inline void request::clear_requestbuf() {
requestbuf_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
_impl_.requestbuf_.ClearToEmpty();
_impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& request::requestbuf() const {
// @@protoc_insertion_point(field_get:cl_rcon.request.requestBuf)
@ -362,8 +353,8 @@ inline const std::string& request::requestbuf() const {
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void request::set_requestbuf(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
requestbuf_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
_impl_._has_bits_[0] |= 0x00000001u;
_impl_.requestbuf_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:cl_rcon.request.requestBuf)
}
inline std::string* request::mutable_requestbuf() {
@ -372,41 +363,40 @@ inline std::string* request::mutable_requestbuf() {
return _s;
}
inline const std::string& request::_internal_requestbuf() const {
return requestbuf_.Get();
return _impl_.requestbuf_.Get();
}
inline void request::_internal_set_requestbuf(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
requestbuf_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
_impl_._has_bits_[0] |= 0x00000001u;
_impl_.requestbuf_.Set(value, GetArenaForAllocation());
}
inline std::string* request::_internal_mutable_requestbuf() {
_has_bits_[0] |= 0x00000001u;
return requestbuf_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
_impl_._has_bits_[0] |= 0x00000001u;
return _impl_.requestbuf_.Mutable(GetArenaForAllocation());
}
inline std::string* request::release_requestbuf() {
// @@protoc_insertion_point(field_release:cl_rcon.request.requestBuf)
if (!_internal_has_requestbuf()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = requestbuf_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
_impl_._has_bits_[0] &= ~0x00000001u;
auto* p = _impl_.requestbuf_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (requestbuf_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
requestbuf_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
if (_impl_.requestbuf_.IsDefault()) {
_impl_.requestbuf_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void request::set_allocated_requestbuf(std::string* requestbuf) {
if (requestbuf != nullptr) {
_has_bits_[0] |= 0x00000001u;
_impl_._has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
_impl_._has_bits_[0] &= ~0x00000001u;
}
requestbuf_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), requestbuf,
GetArenaForAllocation());
_impl_.requestbuf_.SetAllocated(requestbuf, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (requestbuf_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
requestbuf_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
if (_impl_.requestbuf_.IsDefault()) {
_impl_.requestbuf_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:cl_rcon.request.requestBuf)
@ -414,15 +404,15 @@ inline void request::set_allocated_requestbuf(std::string* requestbuf) {
// optional string requestVal = 4;
inline bool request::_internal_has_requestval() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool request::has_requestval() const {
return _internal_has_requestval();
}
inline void request::clear_requestval() {
requestval_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
_impl_.requestval_.ClearToEmpty();
_impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& request::requestval() const {
// @@protoc_insertion_point(field_get:cl_rcon.request.requestVal)
@ -431,8 +421,8 @@ inline const std::string& request::requestval() const {
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void request::set_requestval(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000002u;
requestval_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
_impl_._has_bits_[0] |= 0x00000002u;
_impl_.requestval_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:cl_rcon.request.requestVal)
}
inline std::string* request::mutable_requestval() {
@ -441,41 +431,40 @@ inline std::string* request::mutable_requestval() {
return _s;
}
inline const std::string& request::_internal_requestval() const {
return requestval_.Get();
return _impl_.requestval_.Get();
}
inline void request::_internal_set_requestval(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
requestval_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
_impl_._has_bits_[0] |= 0x00000002u;
_impl_.requestval_.Set(value, GetArenaForAllocation());
}
inline std::string* request::_internal_mutable_requestval() {
_has_bits_[0] |= 0x00000002u;
return requestval_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
_impl_._has_bits_[0] |= 0x00000002u;
return _impl_.requestval_.Mutable(GetArenaForAllocation());
}
inline std::string* request::release_requestval() {
// @@protoc_insertion_point(field_release:cl_rcon.request.requestVal)
if (!_internal_has_requestval()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
auto* p = requestval_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
_impl_._has_bits_[0] &= ~0x00000002u;
auto* p = _impl_.requestval_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (requestval_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
requestval_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
if (_impl_.requestval_.IsDefault()) {
_impl_.requestval_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void request::set_allocated_requestval(std::string* requestval) {
if (requestval != nullptr) {
_has_bits_[0] |= 0x00000002u;
_impl_._has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
_impl_._has_bits_[0] &= ~0x00000002u;
}
requestval_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), requestval,
GetArenaForAllocation());
_impl_.requestval_.SetAllocated(requestval, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (requestval_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
requestval_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
if (_impl_.requestval_.IsDefault()) {
_impl_.requestval_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:cl_rcon.request.requestVal)

144
r5dev/protoc/sig_map.pb.cc
View File

@ -13,29 +13,34 @@
#include <thirdparty/protobuf/port_def.inc>
PROTOBUF_PRAGMA_INIT_SEG
constexpr SigMap_Pb_SMapEntry_DoNotUse::SigMap_Pb_SMapEntry_DoNotUse(
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
namespace _pb = ::PROTOBUF_NAMESPACE_ID;
namespace _pbi = _pb::internal;
PROTOBUF_CONSTEXPR SigMap_Pb_SMapEntry_DoNotUse::SigMap_Pb_SMapEntry_DoNotUse(
::_pbi::ConstantInitialized) {}
struct SigMap_Pb_SMapEntry_DoNotUseDefaultTypeInternal {
constexpr SigMap_Pb_SMapEntry_DoNotUseDefaultTypeInternal()
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
PROTOBUF_CONSTEXPR SigMap_Pb_SMapEntry_DoNotUseDefaultTypeInternal()
: _instance(::_pbi::ConstantInitialized{}) {}
~SigMap_Pb_SMapEntry_DoNotUseDefaultTypeInternal() {}
union {
SigMap_Pb_SMapEntry_DoNotUse _instance;
};
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SigMap_Pb_SMapEntry_DoNotUseDefaultTypeInternal _SigMap_Pb_SMapEntry_DoNotUse_default_instance_;
constexpr SigMap_Pb::SigMap_Pb(
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
: smap_(){}
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SigMap_Pb_SMapEntry_DoNotUseDefaultTypeInternal _SigMap_Pb_SMapEntry_DoNotUse_default_instance_;
PROTOBUF_CONSTEXPR SigMap_Pb::SigMap_Pb(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_.smap_)*/{}
, /*decltype(_impl_._cached_size_)*/{}} {}
struct SigMap_PbDefaultTypeInternal {
constexpr SigMap_PbDefaultTypeInternal()
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
PROTOBUF_CONSTEXPR SigMap_PbDefaultTypeInternal()
: _instance(::_pbi::ConstantInitialized{}) {}
~SigMap_PbDefaultTypeInternal() {}
union {
SigMap_Pb _instance;
};
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SigMap_PbDefaultTypeInternal _SigMap_Pb_default_instance_;
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SigMap_PbDefaultTypeInternal _SigMap_Pb_default_instance_;
// ===================================================================
@ -54,43 +59,49 @@ class SigMap_Pb::_Internal {
SigMap_Pb::SigMap_Pb(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned)
: ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned),
smap_(arena) {
SharedCtor();
if (!is_message_owned) {
RegisterArenaDtor(arena);
}
: ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
SharedCtor(arena, is_message_owned);
// @@protoc_insertion_point(arena_constructor:SigMap_Pb)
}
SigMap_Pb::SigMap_Pb(const SigMap_Pb& from)
: ::PROTOBUF_NAMESPACE_ID::MessageLite() {
SigMap_Pb* const _this = this; (void)_this;
new (&_impl_) Impl_{
/*decltype(_impl_.smap_)*/{}
, /*decltype(_impl_._cached_size_)*/{}};
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
smap_.MergeFrom(from.smap_);
_this->_impl_.smap_.MergeFrom(from._impl_.smap_);
// @@protoc_insertion_point(copy_constructor:SigMap_Pb)
}
inline void SigMap_Pb::SharedCtor() {
inline void SigMap_Pb::SharedCtor(
::_pb::Arena* arena, bool is_message_owned) {
(void)arena;
(void)is_message_owned;
new (&_impl_) Impl_{
/*decltype(_impl_.smap_)*/{::_pbi::ArenaInitialized(), arena}
, /*decltype(_impl_._cached_size_)*/{}
};
}
SigMap_Pb::~SigMap_Pb() {
// @@protoc_insertion_point(destructor:SigMap_Pb)
if (GetArenaForAllocation() != nullptr) return;
if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
(void)arena;
return;
}
SharedDtor();
_internal_metadata_.Delete<std::string>();
}
inline void SigMap_Pb::SharedDtor() {
GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
_impl_.smap_.Destruct();
_impl_.smap_.~MapFieldLite();
}
void SigMap_Pb::ArenaDtor(void* object) {
SigMap_Pb* _this = reinterpret_cast< SigMap_Pb* >(object);
(void)_this;
}
void SigMap_Pb::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void SigMap_Pb::SetCachedSize(int size) const {
_cached_size_.Set(size);
_impl_._cached_size_.Set(size);
}
void SigMap_Pb::Clear() {
@ -99,15 +110,15 @@ void SigMap_Pb::Clear() {
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
smap_.Clear();
_impl_.smap_.Clear();
_internal_metadata_.Clear<std::string>();
}
const char* SigMap_Pb::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
const char* SigMap_Pb::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
while (!ctx->Done(&ptr)) {
uint32_t tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
ptr = ::_pbi::ReadTag(ptr, &tag);
switch (tag >> 3) {
// map<string, uint64> sMap = 1;
case 1:
@ -115,7 +126,7 @@ const char* SigMap_Pb::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::
ptr -= 1;
do {
ptr += 1;
ptr = ctx->ParseMessage(&smap_, ptr);
ptr = ctx->ParseMessage(&_impl_.smap_, ptr);
CHK_(ptr);
if (!ctx->DataAvailable(ptr)) break;
} while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
@ -153,42 +164,26 @@ uint8_t* SigMap_Pb::_InternalSerialize(
// map<string, uint64> sMap = 1;
if (!this->_internal_smap().empty()) {
typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >::const_pointer
ConstPtr;
typedef ConstPtr SortItem;
typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByDerefFirst<SortItem> Less;
struct Utf8Check {
static void Check(ConstPtr p) {
(void)p;
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
p->first.data(), static_cast<int>(p->first.length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
"SigMap_Pb.SMapEntry.key");
}
using MapType = ::_pb::Map<std::string, uint64_t>;
using WireHelper = SigMap_Pb_SMapEntry_DoNotUse::Funcs;
const auto& map_field = this->_internal_smap();
auto check_utf8 = [](const MapType::value_type& entry) {
(void)entry;
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
entry.first.data(), static_cast<int>(entry.first.length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
"SigMap_Pb.SMapEntry.key");
};
if (stream->IsSerializationDeterministic() &&
this->_internal_smap().size() > 1) {
::std::unique_ptr<SortItem[]> items(
new SortItem[this->_internal_smap().size()]);
typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >::size_type size_type;
size_type n = 0;
for (::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >::const_iterator
it = this->_internal_smap().begin();
it != this->_internal_smap().end(); ++it, ++n) {
items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
}
::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
for (size_type i = 0; i < n; i++) {
target = SigMap_Pb_SMapEntry_DoNotUse::Funcs::InternalSerialize(1, items[static_cast<ptrdiff_t>(i)]->first, items[static_cast<ptrdiff_t>(i)]->second, target, stream);
Utf8Check::Check(&(*items[static_cast<ptrdiff_t>(i)]));
if (stream->IsSerializationDeterministic() && map_field.size() > 1) {
for (const auto& entry : ::_pbi::MapSorterPtr<MapType>(map_field)) {
target = WireHelper::InternalSerialize(1, entry.first, entry.second, target, stream);
check_utf8(entry);
}
} else {
for (::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >::const_iterator
it = this->_internal_smap().begin();
it != this->_internal_smap().end(); ++it) {
target = SigMap_Pb_SMapEntry_DoNotUse::Funcs::InternalSerialize(1, it->first, it->second, target, stream);
Utf8Check::Check(&(*it));
for (const auto& entry : map_field) {
target = WireHelper::InternalSerialize(1, entry.first, entry.second, target, stream);
check_utf8(entry);
}
}
}
@ -221,25 +216,26 @@ size_t SigMap_Pb::ByteSizeLong() const {
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
}
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
int cached_size = ::_pbi::ToCachedSize(total_size);
SetCachedSize(cached_size);
return total_size;
}
void SigMap_Pb::CheckTypeAndMergeFrom(
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const SigMap_Pb*>(
MergeFrom(*::_pbi::DownCast<const SigMap_Pb*>(
&from));
}
void SigMap_Pb::MergeFrom(const SigMap_Pb& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SigMap_Pb)
GOOGLE_DCHECK_NE(&from, this);
SigMap_Pb* const _this = this;
// @@protoc_insertion_point(class_specific_merge_from_start:SigMap_Pb)
GOOGLE_DCHECK_NE(&from, _this);
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
smap_.MergeFrom(from.smap_);
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
_this->_impl_.smap_.MergeFrom(from._impl_.smap_);
_this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}
void SigMap_Pb::CopyFrom(const SigMap_Pb& from) {
@ -256,7 +252,7 @@ bool SigMap_Pb::IsInitialized() const {
void SigMap_Pb::InternalSwap(SigMap_Pb* other) {
using std::swap;
_internal_metadata_.InternalSwap(&other->_internal_metadata_);
smap_.InternalSwap(&other->smap_);
_impl_.smap_.InternalSwap(&other->_impl_.smap_);
}
std::string SigMap_Pb::GetTypeName() const {
@ -266,10 +262,12 @@ std::string SigMap_Pb::GetTypeName() const {
// @@protoc_insertion_point(namespace_scope)
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::SigMap_Pb_SMapEntry_DoNotUse* Arena::CreateMaybeMessage< ::SigMap_Pb_SMapEntry_DoNotUse >(Arena* arena) {
template<> PROTOBUF_NOINLINE ::SigMap_Pb_SMapEntry_DoNotUse*
Arena::CreateMaybeMessage< ::SigMap_Pb_SMapEntry_DoNotUse >(Arena* arena) {
return Arena::CreateMessageInternal< ::SigMap_Pb_SMapEntry_DoNotUse >(arena);
}
template<> PROTOBUF_NOINLINE ::SigMap_Pb* Arena::CreateMaybeMessage< ::SigMap_Pb >(Arena* arena) {
template<> PROTOBUF_NOINLINE ::SigMap_Pb*
Arena::CreateMaybeMessage< ::SigMap_Pb >(Arena* arena) {
return Arena::CreateMessageInternal< ::SigMap_Pb >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

48
r5dev/protoc/sig_map.pb.h
View File

@ -8,12 +8,12 @@
#include <string>
#include <thirdparty/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3019000
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3019004 < PROTOBUF_MIN_PROTOC_VERSION
#if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
@ -23,7 +23,6 @@
#include <thirdparty/protobuf/io/coded_stream.h>
#include <thirdparty/protobuf/arena.h>
#include <thirdparty/protobuf/arenastring.h>
#include <thirdparty/protobuf/generated_message_table_driven.h>
#include <thirdparty/protobuf/generated_message_util.h>
#include <thirdparty/protobuf/metadata_lite.h>
#include <thirdparty/protobuf/message_lite.h>
@ -43,14 +42,6 @@ PROTOBUF_NAMESPACE_CLOSE
// Internal implementation detail -- do not use these members.
struct TableStruct_sig_5fmap_2eproto {
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
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[2]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
static const uint32_t offsets[];
};
class SigMap_Pb;
@ -76,7 +67,7 @@ public:
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64> SuperType;
SigMap_Pb_SMapEntry_DoNotUse();
explicit constexpr SigMap_Pb_SMapEntry_DoNotUse(
explicit PROTOBUF_CONSTEXPR SigMap_Pb_SMapEntry_DoNotUse(
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
explicit SigMap_Pb_SMapEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
void MergeFrom(const SigMap_Pb_SMapEntry_DoNotUse& other);
@ -85,6 +76,7 @@ public:
return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "SigMap_Pb.SMapEntry.key");
}
static bool ValidateValue(void*) { return true; }
friend struct ::TableStruct_sig_5fmap_2eproto;
};
// -------------------------------------------------------------------
@ -94,7 +86,7 @@ class SigMap_Pb final :
public:
inline SigMap_Pb() : SigMap_Pb(nullptr) {}
~SigMap_Pb() override;
explicit constexpr SigMap_Pb(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
explicit PROTOBUF_CONSTEXPR SigMap_Pb(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
SigMap_Pb(const SigMap_Pb& from);
SigMap_Pb(SigMap_Pb&& from) noexcept
@ -167,10 +159,10 @@ class SigMap_Pb final :
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor();
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(SigMap_Pb* other);
@ -183,9 +175,6 @@ class SigMap_Pb final :
protected:
explicit SigMap_Pb(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
@ -222,12 +211,15 @@ class SigMap_Pb final :
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::MapFieldLite<
SigMap_Pb_SMapEntry_DoNotUse,
std::string, uint64_t,
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64> smap_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::internal::MapFieldLite<
SigMap_Pb_SMapEntry_DoNotUse,
std::string, uint64_t,
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64> smap_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_sig_5fmap_2eproto;
};
// ===================================================================
@ -245,17 +237,17 @@ class SigMap_Pb final :
// map<string, uint64> sMap = 1;
inline int SigMap_Pb::_internal_smap_size() const {
return smap_.size();
return _impl_.smap_.size();
}
inline int SigMap_Pb::smap_size() const {
return _internal_smap_size();
}
inline void SigMap_Pb::clear_smap() {
smap_.Clear();
_impl_.smap_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >&
SigMap_Pb::_internal_smap() const {
return smap_.GetMap();
return _impl_.smap_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >&
SigMap_Pb::smap() const {
@ -264,7 +256,7 @@ SigMap_Pb::smap() const {
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >*
SigMap_Pb::_internal_mutable_smap() {
return smap_.MutableMap();
return _impl_.smap_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >*
SigMap_Pb::mutable_smap() {

205
r5dev/protoc/sv_rcon.pb.cc
View File

@ -13,23 +13,28 @@
#include <thirdparty/protobuf/port_def.inc>
PROTOBUF_PRAGMA_INIT_SEG
namespace _pb = ::PROTOBUF_NAMESPACE_ID;
namespace _pbi = _pb::internal;
namespace sv_rcon {
constexpr response::response(
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
: responsebuf_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
, responseval_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
, responseid_(0)
, responsetype_(0)
{}
PROTOBUF_CONSTEXPR response::response(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_._has_bits_)*/{}
, /*decltype(_impl_._cached_size_)*/{}
, /*decltype(_impl_.responsebuf_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
, /*decltype(_impl_.responseval_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
, /*decltype(_impl_.responseid_)*/0
, /*decltype(_impl_.responsetype_)*/0} {}
struct responseDefaultTypeInternal {
constexpr responseDefaultTypeInternal()
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
PROTOBUF_CONSTEXPR responseDefaultTypeInternal()
: _instance(::_pbi::ConstantInitialized{}) {}
~responseDefaultTypeInternal() {}
union {
response _instance;
};
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT responseDefaultTypeInternal _response_default_instance_;
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 responseDefaultTypeInternal _response_default_instance_;
} // namespace sv_rcon
namespace sv_rcon {
bool response_t_IsValid(int value) {
@ -104,7 +109,7 @@ bool response_t_Parse(
class response::_Internal {
public:
using HasBits = decltype(std::declval<response>()._has_bits_);
using HasBits = decltype(std::declval<response>()._impl_._has_bits_);
static void set_has_responseid(HasBits* has_bits) {
(*has_bits)[0] |= 4u;
}
@ -122,74 +127,82 @@ class response::_Internal {
response::response(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned)
: ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
SharedCtor();
if (!is_message_owned) {
RegisterArenaDtor(arena);
}
SharedCtor(arena, is_message_owned);
// @@protoc_insertion_point(arena_constructor:sv_rcon.response)
}
response::response(const response& from)
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
_has_bits_(from._has_bits_) {
: ::PROTOBUF_NAMESPACE_ID::MessageLite() {
response* const _this = this; (void)_this;
new (&_impl_) Impl_{
decltype(_impl_._has_bits_){from._impl_._has_bits_}
, /*decltype(_impl_._cached_size_)*/{}
, decltype(_impl_.responsebuf_){}
, decltype(_impl_.responseval_){}
, decltype(_impl_.responseid_){}
, decltype(_impl_.responsetype_){}};
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
responsebuf_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
_impl_.responsebuf_.InitDefault();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
responsebuf_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
_impl_.responsebuf_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (from._internal_has_responsebuf()) {
responsebuf_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_responsebuf(),
GetArenaForAllocation());
_this->_impl_.responsebuf_.Set(from._internal_responsebuf(),
_this->GetArenaForAllocation());
}
responseval_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
_impl_.responseval_.InitDefault();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
responseval_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
_impl_.responseval_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (from._internal_has_responseval()) {
responseval_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_responseval(),
GetArenaForAllocation());
_this->_impl_.responseval_.Set(from._internal_responseval(),
_this->GetArenaForAllocation());
}
::memcpy(&responseid_, &from.responseid_,
static_cast<size_t>(reinterpret_cast<char*>(&responsetype_) -
reinterpret_cast<char*>(&responseid_)) + sizeof(responsetype_));
::memcpy(&_impl_.responseid_, &from._impl_.responseid_,
static_cast<size_t>(reinterpret_cast<char*>(&_impl_.responsetype_) -
reinterpret_cast<char*>(&_impl_.responseid_)) + sizeof(_impl_.responsetype_));
// @@protoc_insertion_point(copy_constructor:sv_rcon.response)
}
inline void response::SharedCtor() {
responsebuf_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
responsebuf_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
responseval_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
responseval_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
reinterpret_cast<char*>(&responseid_) - reinterpret_cast<char*>(this)),
0, static_cast<size_t>(reinterpret_cast<char*>(&responsetype_) -
reinterpret_cast<char*>(&responseid_)) + sizeof(responsetype_));
inline void response::SharedCtor(
::_pb::Arena* arena, bool is_message_owned) {
(void)arena;
(void)is_message_owned;
new (&_impl_) Impl_{
decltype(_impl_._has_bits_){}
, /*decltype(_impl_._cached_size_)*/{}
, decltype(_impl_.responsebuf_){}
, decltype(_impl_.responseval_){}
, decltype(_impl_.responseid_){0}
, decltype(_impl_.responsetype_){0}
};
_impl_.responsebuf_.InitDefault();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
_impl_.responsebuf_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
_impl_.responseval_.InitDefault();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
_impl_.responseval_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}
response::~response() {
// @@protoc_insertion_point(destructor:sv_rcon.response)
if (GetArenaForAllocation() != nullptr) return;
if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
(void)arena;
return;
}
SharedDtor();
_internal_metadata_.Delete<std::string>();
}
inline void response::SharedDtor() {
GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
responsebuf_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
responseval_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
_impl_.responsebuf_.Destroy();
_impl_.responseval_.Destroy();
}
void response::ArenaDtor(void* object) {
response* _this = reinterpret_cast< response* >(object);
(void)_this;
}
void response::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void response::SetCachedSize(int size) const {
_cached_size_.Set(size);
_impl_._cached_size_.Set(size);
}
void response::Clear() {
@ -198,36 +211,36 @@ void response::Clear() {
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
cached_has_bits = _impl_._has_bits_[0];
if (cached_has_bits & 0x00000003u) {
if (cached_has_bits & 0x00000001u) {
responsebuf_.ClearNonDefaultToEmpty();
_impl_.responsebuf_.ClearNonDefaultToEmpty();
}
if (cached_has_bits & 0x00000002u) {
responseval_.ClearNonDefaultToEmpty();
_impl_.responseval_.ClearNonDefaultToEmpty();
}
}
if (cached_has_bits & 0x0000000cu) {
::memset(&responseid_, 0, static_cast<size_t>(
reinterpret_cast<char*>(&responsetype_) -
reinterpret_cast<char*>(&responseid_)) + sizeof(responsetype_));
::memset(&_impl_.responseid_, 0, static_cast<size_t>(
reinterpret_cast<char*>(&_impl_.responsetype_) -
reinterpret_cast<char*>(&_impl_.responseid_)) + sizeof(_impl_.responsetype_));
}
_has_bits_.Clear();
_impl_._has_bits_.Clear();
_internal_metadata_.Clear<std::string>();
}
const char* response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
const char* response::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
_Internal::HasBits has_bits{};
while (!ctx->Done(&ptr)) {
uint32_t tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
ptr = ::_pbi::ReadTag(ptr, &tag);
switch (tag >> 3) {
// optional int32 responseID = 1;
case 1:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
_Internal::set_has_responseid(&has_bits);
responseid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
_impl_.responseid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
CHK_(ptr);
} else
goto handle_unusual;
@ -245,9 +258,9 @@ const char* response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::i
case 3:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
auto str = _internal_mutable_responsebuf();
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
CHK_(ptr);
CHK_(::_pbi::VerifyUTF8(str, nullptr));
} else
goto handle_unusual;
continue;
@ -255,9 +268,9 @@ const char* response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::i
case 4:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
auto str = _internal_mutable_responseval();
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
CHK_(ptr);
CHK_(::_pbi::VerifyUTF8(str, nullptr));
} else
goto handle_unusual;
continue;
@ -277,7 +290,7 @@ const char* response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::i
CHK_(ptr != nullptr);
} // while
message_done:
_has_bits_.Or(has_bits);
_impl_._has_bits_.Or(has_bits);
return ptr;
failure:
ptr = nullptr;
@ -294,13 +307,13 @@ uint8_t* response::_InternalSerialize(
// optional int32 responseID = 1;
if (_internal_has_responseid()) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_responseid(), target);
target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_responseid(), target);
}
// optional .sv_rcon.response_t responseType = 2;
if (_internal_has_responsetype()) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
target = ::_pbi::WireFormatLite::WriteEnumToArray(
2, this->_internal_responsetype(), target);
}
@ -340,7 +353,7 @@ size_t response::ByteSizeLong() const {
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
cached_has_bits = _impl_._has_bits_[0];
if (cached_has_bits & 0x0000000fu) {
// optional string responseBuf = 3;
if (cached_has_bits & 0x00000001u) {
@ -358,53 +371,54 @@ size_t response::ByteSizeLong() const {
// optional int32 responseID = 1;
if (cached_has_bits & 0x00000004u) {
total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_responseid());
total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_responseid());
}
// optional .sv_rcon.response_t responseType = 2;
if (cached_has_bits & 0x00000008u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_responsetype());
::_pbi::WireFormatLite::EnumSize(this->_internal_responsetype());
}
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
}
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
int cached_size = ::_pbi::ToCachedSize(total_size);
SetCachedSize(cached_size);
return total_size;
}
void response::CheckTypeAndMergeFrom(
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const response*>(
MergeFrom(*::_pbi::DownCast<const response*>(
&from));
}
void response::MergeFrom(const response& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:sv_rcon.response)
GOOGLE_DCHECK_NE(&from, this);
response* const _this = this;
// @@protoc_insertion_point(class_specific_merge_from_start:sv_rcon.response)
GOOGLE_DCHECK_NE(&from, _this);
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
cached_has_bits = from._has_bits_[0];
cached_has_bits = from._impl_._has_bits_[0];
if (cached_has_bits & 0x0000000fu) {
if (cached_has_bits & 0x00000001u) {
_internal_set_responsebuf(from._internal_responsebuf());
_this->_internal_set_responsebuf(from._internal_responsebuf());
}
if (cached_has_bits & 0x00000002u) {
_internal_set_responseval(from._internal_responseval());
_this->_internal_set_responseval(from._internal_responseval());
}
if (cached_has_bits & 0x00000004u) {
responseid_ = from.responseid_;
_this->_impl_.responseid_ = from._impl_.responseid_;
}
if (cached_has_bits & 0x00000008u) {
responsetype_ = from.responsetype_;
_this->_impl_.responsetype_ = from._impl_.responsetype_;
}
_has_bits_[0] |= cached_has_bits;
_this->_impl_._has_bits_[0] |= cached_has_bits;
}
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
_this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}
void response::CopyFrom(const response& from) {
@ -423,23 +437,21 @@ void response::InternalSwap(response* other) {
auto* lhs_arena = GetArenaForAllocation();
auto* rhs_arena = other->GetArenaForAllocation();
_internal_metadata_.InternalSwap(&other->_internal_metadata_);
swap(_has_bits_[0], other->_has_bits_[0]);
swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
&responsebuf_, lhs_arena,
&other->responsebuf_, rhs_arena
&_impl_.responsebuf_, lhs_arena,
&other->_impl_.responsebuf_, rhs_arena
);
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
&responseval_, lhs_arena,
&other->responseval_, rhs_arena
&_impl_.responseval_, lhs_arena,
&other->_impl_.responseval_, rhs_arena
);
::PROTOBUF_NAMESPACE_ID::internal::memswap<
PROTOBUF_FIELD_OFFSET(response, responsetype_)
+ sizeof(response::responsetype_)
- PROTOBUF_FIELD_OFFSET(response, responseid_)>(
reinterpret_cast<char*>(&responseid_),
reinterpret_cast<char*>(&other->responseid_));
PROTOBUF_FIELD_OFFSET(response, _impl_.responsetype_)
+ sizeof(response::_impl_.responsetype_)
- PROTOBUF_FIELD_OFFSET(response, _impl_.responseid_)>(
reinterpret_cast<char*>(&_impl_.responseid_),
reinterpret_cast<char*>(&other->_impl_.responseid_));
}
std::string response::GetTypeName() const {
@ -450,7 +462,8 @@ std::string response::GetTypeName() const {
// @@protoc_insertion_point(namespace_scope)
} // namespace sv_rcon
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::sv_rcon::response* Arena::CreateMaybeMessage< ::sv_rcon::response >(Arena* arena) {
template<> PROTOBUF_NOINLINE ::sv_rcon::response*
Arena::CreateMaybeMessage< ::sv_rcon::response >(Arena* arena) {
return Arena::CreateMessageInternal< ::sv_rcon::response >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

139
r5dev/protoc/sv_rcon.pb.h
View File

@ -8,12 +8,12 @@
#include <string>
#include <thirdparty/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3019000
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3019004 < PROTOBUF_MIN_PROTOC_VERSION
#if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
@ -23,7 +23,6 @@
#include <thirdparty/protobuf/io/coded_stream.h>
#include <thirdparty/protobuf/arena.h>
#include <thirdparty/protobuf/arenastring.h>
#include <thirdparty/protobuf/generated_message_table_driven.h>
#include <thirdparty/protobuf/generated_message_util.h>
#include <thirdparty/protobuf/metadata_lite.h>
#include <thirdparty/protobuf/message_lite.h>
@ -41,14 +40,6 @@ PROTOBUF_NAMESPACE_CLOSE
// Internal implementation detail -- do not use these members.
struct TableStruct_sv_5frcon_2eproto {
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
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[1]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
static const uint32_t offsets[];
};
namespace sv_rcon {
@ -93,7 +84,7 @@ class response final :
public:
inline response() : response(nullptr) {}
~response() override;
explicit constexpr response(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
explicit PROTOBUF_CONSTEXPR response(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
response(const response& from);
response(response&& from) noexcept
@ -166,10 +157,10 @@ class response final :
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor();
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(response* other);
@ -182,9 +173,6 @@ class response final :
protected:
explicit response(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
@ -268,12 +256,15 @@ class response final :
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr responsebuf_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr responseval_;
int32_t responseid_;
int responsetype_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr responsebuf_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr responseval_;
int32_t responseid_;
int responsetype_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_sv_5frcon_2eproto;
};
// ===================================================================
@ -289,26 +280,26 @@ class response final :
// optional int32 responseID = 1;
inline bool response::_internal_has_responseid() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool response::has_responseid() const {
return _internal_has_responseid();
}
inline void response::clear_responseid() {
responseid_ = 0;
_has_bits_[0] &= ~0x00000004u;
_impl_.responseid_ = 0;
_impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t response::_internal_responseid() const {
return responseid_;
return _impl_.responseid_;
}
inline int32_t response::responseid() const {
// @@protoc_insertion_point(field_get:sv_rcon.response.responseID)
return _internal_responseid();
}
inline void response::_internal_set_responseid(int32_t value) {
_has_bits_[0] |= 0x00000004u;
responseid_ = value;
_impl_._has_bits_[0] |= 0x00000004u;
_impl_.responseid_ = value;
}
inline void response::set_responseid(int32_t value) {
_internal_set_responseid(value);
@ -317,26 +308,26 @@ inline void response::set_responseid(int32_t value) {
// optional .sv_rcon.response_t responseType = 2;
inline bool response::_internal_has_responsetype() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool response::has_responsetype() const {
return _internal_has_responsetype();
}
inline void response::clear_responsetype() {
responsetype_ = 0;
_has_bits_[0] &= ~0x00000008u;
_impl_.responsetype_ = 0;
_impl_._has_bits_[0] &= ~0x00000008u;
}
inline ::sv_rcon::response_t response::_internal_responsetype() const {
return static_cast< ::sv_rcon::response_t >(responsetype_);
return static_cast< ::sv_rcon::response_t >(_impl_.responsetype_);
}
inline ::sv_rcon::response_t response::responsetype() const {
// @@protoc_insertion_point(field_get:sv_rcon.response.responseType)
return _internal_responsetype();
}
inline void response::_internal_set_responsetype(::sv_rcon::response_t value) {
_has_bits_[0] |= 0x00000008u;
responsetype_ = value;
_impl_._has_bits_[0] |= 0x00000008u;
_impl_.responsetype_ = value;
}
inline void response::set_responsetype(::sv_rcon::response_t value) {
_internal_set_responsetype(value);
@ -345,15 +336,15 @@ inline void response::set_responsetype(::sv_rcon::response_t value) {
// optional string responseBuf = 3;
inline bool response::_internal_has_responsebuf() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool response::has_responsebuf() const {
return _internal_has_responsebuf();
}
inline void response::clear_responsebuf() {
responsebuf_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
_impl_.responsebuf_.ClearToEmpty();
_impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& response::responsebuf() const {
// @@protoc_insertion_point(field_get:sv_rcon.response.responseBuf)
@ -362,8 +353,8 @@ inline const std::string& response::responsebuf() const {
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void response::set_responsebuf(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
responsebuf_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
_impl_._has_bits_[0] |= 0x00000001u;
_impl_.responsebuf_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:sv_rcon.response.responseBuf)
}
inline std::string* response::mutable_responsebuf() {
@ -372,41 +363,40 @@ inline std::string* response::mutable_responsebuf() {
return _s;
}
inline const std::string& response::_internal_responsebuf() const {
return responsebuf_.Get();
return _impl_.responsebuf_.Get();
}
inline void response::_internal_set_responsebuf(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
responsebuf_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
_impl_._has_bits_[0] |= 0x00000001u;
_impl_.responsebuf_.Set(value, GetArenaForAllocation());
}
inline std::string* response::_internal_mutable_responsebuf() {
_has_bits_[0] |= 0x00000001u;
return responsebuf_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
_impl_._has_bits_[0] |= 0x00000001u;
return _impl_.responsebuf_.Mutable(GetArenaForAllocation());
}
inline std::string* response::release_responsebuf() {
// @@protoc_insertion_point(field_release:sv_rcon.response.responseBuf)
if (!_internal_has_responsebuf()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = responsebuf_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
_impl_._has_bits_[0] &= ~0x00000001u;
auto* p = _impl_.responsebuf_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (responsebuf_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
responsebuf_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
if (_impl_.responsebuf_.IsDefault()) {
_impl_.responsebuf_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void response::set_allocated_responsebuf(std::string* responsebuf) {
if (responsebuf != nullptr) {
_has_bits_[0] |= 0x00000001u;
_impl_._has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
_impl_._has_bits_[0] &= ~0x00000001u;
}
responsebuf_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), responsebuf,
GetArenaForAllocation());
_impl_.responsebuf_.SetAllocated(responsebuf, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (responsebuf_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
responsebuf_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
if (_impl_.responsebuf_.IsDefault()) {
_impl_.responsebuf_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:sv_rcon.response.responseBuf)
@ -414,15 +404,15 @@ inline void response::set_allocated_responsebuf(std::string* responsebuf) {
// optional string responseVal = 4;
inline bool response::_internal_has_responseval() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool response::has_responseval() const {
return _internal_has_responseval();
}
inline void response::clear_responseval() {
responseval_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
_impl_.responseval_.ClearToEmpty();
_impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& response::responseval() const {
// @@protoc_insertion_point(field_get:sv_rcon.response.responseVal)
@ -431,8 +421,8 @@ inline const std::string& response::responseval() const {
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void response::set_responseval(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000002u;
responseval_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
_impl_._has_bits_[0] |= 0x00000002u;
_impl_.responseval_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:sv_rcon.response.responseVal)
}
inline std::string* response::mutable_responseval() {
@ -441,41 +431,40 @@ inline std::string* response::mutable_responseval() {
return _s;
}
inline const std::string& response::_internal_responseval() const {
return responseval_.Get();
return _impl_.responseval_.Get();
}
inline void response::_internal_set_responseval(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
responseval_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
_impl_._has_bits_[0] |= 0x00000002u;
_impl_.responseval_.Set(value, GetArenaForAllocation());
}
inline std::string* response::_internal_mutable_responseval() {
_has_bits_[0] |= 0x00000002u;
return responseval_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
_impl_._has_bits_[0] |= 0x00000002u;
return _impl_.responseval_.Mutable(GetArenaForAllocation());
}
inline std::string* response::release_responseval() {
// @@protoc_insertion_point(field_release:sv_rcon.response.responseVal)
if (!_internal_has_responseval()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
auto* p = responseval_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
_impl_._has_bits_[0] &= ~0x00000002u;
auto* p = _impl_.responseval_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (responseval_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
responseval_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
if (_impl_.responseval_.IsDefault()) {
_impl_.responseval_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void response::set_allocated_responseval(std::string* responseval) {
if (responseval != nullptr) {
_has_bits_[0] |= 0x00000002u;
_impl_._has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
_impl_._has_bits_[0] &= ~0x00000002u;
}
responseval_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), responseval,
GetArenaForAllocation());
_impl_.responseval_.SetAllocated(responseval, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (responseval_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
responseval_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
if (_impl_.responseval_.IsDefault()) {
_impl_.responseval_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:sv_rcon.response.responseVal)

5
r5dev/thirdparty/protobuf/any.cc vendored
View File

@ -35,6 +35,7 @@
#include <thirdparty/protobuf/generated_message_util.h>
#include <thirdparty/protobuf/message.h>
// Must be included last.
#include <thirdparty/protobuf/port_def.inc>
namespace google {
@ -48,10 +49,8 @@ bool AnyMetadata::PackFrom(Arena* arena, const Message& message) {
bool AnyMetadata::PackFrom(Arena* arena, const Message& message,
StringPiece type_url_prefix) {
type_url_->Set(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString(),
GetTypeUrl(message.GetDescriptor()->full_name(), type_url_prefix), arena);
return message.SerializeToString(
value_->Mutable(ArenaStringPtr::EmptyDefault{}, arena));
return message.SerializeToString(value_->Mutable(arena));
}
bool AnyMetadata::UnpackTo(Message* message) const {

5
r5dev/thirdparty/protobuf/any.h vendored
View File

@ -37,6 +37,7 @@
#include <thirdparty/protobuf/arenastring.h>
#include <thirdparty/protobuf/message_lite.h>
// Must be included last.
#include <thirdparty/protobuf/port_def.inc>
namespace google {
@ -129,8 +130,8 @@ class PROTOBUF_EXPORT AnyMetadata {
// *full_type_name. Returns false if the type_url does not have a "/"
// in the type url separating the full type name.
//
// NOTE: this function is available publicly as:
// google::protobuf::Any() // static method on the generated message type.
// NOTE: this function is available publicly as a static method on the
// generated message type: google::protobuf::Any::ParseAnyTypeUrl()
bool ParseAnyTypeUrl(StringPiece type_url, std::string* full_type_name);
// Get the proto type name and prefix from Any::type_url value. For example,

202
r5dev/thirdparty/protobuf/any.pb.cc vendored
View File

@ -16,25 +16,34 @@
#include <thirdparty/protobuf/port_def.inc>
PROTOBUF_PRAGMA_INIT_SEG
namespace _pb = ::PROTOBUF_NAMESPACE_ID;
namespace _pbi = _pb::internal;
#if defined(__llvm__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wuninitialized"
#endif // __llvm__
PROTOBUF_NAMESPACE_OPEN
constexpr Any::Any(
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
: type_url_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
, value_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
, _any_metadata_(&type_url_, &value_){}
PROTOBUF_CONSTEXPR Any::Any(
::_pbi::ConstantInitialized): _impl_{
/*decltype(_impl_.type_url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
, /*decltype(_impl_.value_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
, /*decltype(_impl_._cached_size_)*/{}
, /*decltype(_impl_._any_metadata_)*/{&_impl_.type_url_, &_impl_.value_}} {}
struct AnyDefaultTypeInternal {
constexpr AnyDefaultTypeInternal()
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
PROTOBUF_CONSTEXPR AnyDefaultTypeInternal()
: _instance(::_pbi::ConstantInitialized{}) {}
~AnyDefaultTypeInternal() {}
union {
Any _instance;
};
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AnyDefaultTypeInternal _Any_default_instance_;
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AnyDefaultTypeInternal _Any_default_instance_;
PROTOBUF_NAMESPACE_CLOSE
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_google_2fprotobuf_2fany_2eproto[1];
static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_google_2fprotobuf_2fany_2eproto = nullptr;
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_google_2fprotobuf_2fany_2eproto = nullptr;
static ::_pb::Metadata file_level_metadata_google_2fprotobuf_2fany_2eproto[1];
static constexpr ::_pb::EnumDescriptor const** file_level_enum_descriptors_google_2fprotobuf_2fany_2eproto = nullptr;
static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_google_2fprotobuf_2fany_2eproto = nullptr;
const uint32_t TableStruct_google_2fprotobuf_2fany_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
~0u, // no _has_bits_
@ -43,15 +52,15 @@ const uint32_t TableStruct_google_2fprotobuf_2fany_2eproto::offsets[] PROTOBUF_S
~0u, // no _oneof_case_
~0u, // no _weak_field_map_
~0u, // no _inlined_string_donated_
PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::Any, type_url_),
PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::Any, value_),
PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::Any, _impl_.type_url_),
PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::Any, _impl_.value_),
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
{ 0, -1, -1, sizeof(::PROTOBUF_NAMESPACE_ID::Any)},
};
static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::PROTOBUF_NAMESPACE_ID::_Any_default_instance_),
static const ::_pb::Message* const file_default_instances[] = {
&::PROTOBUF_NAMESPACE_ID::_Any_default_instance_._instance,
};
const char descriptor_table_protodef_google_2fprotobuf_2fany_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
@ -62,19 +71,21 @@ const char descriptor_table_protodef_google_2fprotobuf_2fany_2eproto[] PROTOBUF_
"anypb\242\002\003GPB\252\002\036Google.Protobuf.WellKnownT"
"ypesb\006proto3"
;
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_google_2fprotobuf_2fany_2eproto_once;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fany_2eproto = {
false, false, 212, descriptor_table_protodef_google_2fprotobuf_2fany_2eproto, "google/protobuf/any.proto",
&descriptor_table_google_2fprotobuf_2fany_2eproto_once, nullptr, 0, 1,
schemas, file_default_instances, TableStruct_google_2fprotobuf_2fany_2eproto::offsets,
file_level_metadata_google_2fprotobuf_2fany_2eproto, file_level_enum_descriptors_google_2fprotobuf_2fany_2eproto, file_level_service_descriptors_google_2fprotobuf_2fany_2eproto,
static ::_pbi::once_flag descriptor_table_google_2fprotobuf_2fany_2eproto_once;
const ::_pbi::DescriptorTable descriptor_table_google_2fprotobuf_2fany_2eproto = {
false, false, 212, descriptor_table_protodef_google_2fprotobuf_2fany_2eproto,
"google/protobuf/any.proto",
&descriptor_table_google_2fprotobuf_2fany_2eproto_once, nullptr, 0, 1,
schemas, file_default_instances, TableStruct_google_2fprotobuf_2fany_2eproto::offsets,
file_level_metadata_google_2fprotobuf_2fany_2eproto, file_level_enum_descriptors_google_2fprotobuf_2fany_2eproto,
file_level_service_descriptors_google_2fprotobuf_2fany_2eproto,
};
PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_google_2fprotobuf_2fany_2eproto_getter() {
PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_google_2fprotobuf_2fany_2eproto_getter() {
return &descriptor_table_google_2fprotobuf_2fany_2eproto;
}
// Force running AddDescriptors() at dynamic initialization time.
PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_google_2fprotobuf_2fany_2eproto(&descriptor_table_google_2fprotobuf_2fany_2eproto);
PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_google_2fprotobuf_2fany_2eproto(&descriptor_table_google_2fprotobuf_2fany_2eproto);
PROTOBUF_NAMESPACE_OPEN
// ===================================================================
@ -83,14 +94,13 @@ bool Any::GetAnyFieldDescriptors(
const ::PROTOBUF_NAMESPACE_ID::Message& message,
const ::PROTOBUF_NAMESPACE_ID::FieldDescriptor** type_url_field,
const ::PROTOBUF_NAMESPACE_ID::FieldDescriptor** value_field) {
return ::PROTOBUF_NAMESPACE_ID::internal::GetAnyFieldDescriptors(
return ::_pbi::GetAnyFieldDescriptors(
message, type_url_field, value_field);
}
bool Any::ParseAnyTypeUrl(
::PROTOBUF_NAMESPACE_ID::ConstStringParam type_url,
std::string* full_type_name) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseAnyTypeUrl(type_url,
full_type_name);
return ::_pbi::ParseAnyTypeUrl(type_url, full_type_name);
}
class Any::_Internal {
@ -99,69 +109,77 @@ class Any::_Internal {
Any::Any(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned)
: ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
_any_metadata_(&type_url_, &value_) {
SharedCtor();
if (!is_message_owned) {
RegisterArenaDtor(arena);
}
: ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
SharedCtor(arena, is_message_owned);
// @@protoc_insertion_point(arena_constructor:google.protobuf.Any)
}
Any::Any(const Any& from)
: ::PROTOBUF_NAMESPACE_ID::Message(),
_any_metadata_(&type_url_, &value_) {
: ::PROTOBUF_NAMESPACE_ID::Message() {
Any* const _this = this; (void)_this;
new (&_impl_) Impl_{
decltype(_impl_.type_url_){}
, decltype(_impl_.value_){}
, /*decltype(_impl_._cached_size_)*/{}
, /*decltype(_impl_._any_metadata_)*/{&_impl_.type_url_, &_impl_.value_}};
_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
type_url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
_impl_.type_url_.InitDefault();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
type_url_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
_impl_.type_url_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (!from._internal_type_url().empty()) {
type_url_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_type_url(),
GetArenaForAllocation());
_this->_impl_.type_url_.Set(from._internal_type_url(),
_this->GetArenaForAllocation());
}
value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
_impl_.value_.InitDefault();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
_impl_.value_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (!from._internal_value().empty()) {
value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_value(),
GetArenaForAllocation());
_this->_impl_.value_.Set(from._internal_value(),
_this->GetArenaForAllocation());
}
// @@protoc_insertion_point(copy_constructor:google.protobuf.Any)
}
inline void Any::SharedCtor() {
type_url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
type_url_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
inline void Any::SharedCtor(
::_pb::Arena* arena, bool is_message_owned) {
(void)arena;
(void)is_message_owned;
new (&_impl_) Impl_{
decltype(_impl_.type_url_){}
, decltype(_impl_.value_){}
, /*decltype(_impl_._cached_size_)*/{}
, /*decltype(_impl_._any_metadata_)*/{&_impl_.type_url_, &_impl_.value_}
};
_impl_.type_url_.InitDefault();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
_impl_.type_url_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
_impl_.value_.InitDefault();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
_impl_.value_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}
Any::~Any() {
// @@protoc_insertion_point(destructor:google.protobuf.Any)
if (GetArenaForAllocation() != nullptr) return;
if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
(void)arena;
return;
}
SharedDtor();
_internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
inline void Any::SharedDtor() {
GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
type_url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
_impl_.type_url_.Destroy();
_impl_.value_.Destroy();
_impl_._any_metadata_.~AnyMetadata();
}
void Any::ArenaDtor(void* object) {
Any* _this = reinterpret_cast< Any* >(object);
(void)_this;
}
void Any::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Any::SetCachedSize(int size) const {
_cached_size_.Set(size);
_impl_._cached_size_.Set(size);
}
void Any::Clear() {
@ -170,24 +188,24 @@ void Any::Clear() {
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
type_url_.ClearToEmpty();
value_.ClearToEmpty();
_impl_.type_url_.ClearToEmpty();
_impl_.value_.ClearToEmpty();
_internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
const char* Any::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
const char* Any::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
while (!ctx->Done(&ptr)) {
uint32_t tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
ptr = ::_pbi::ReadTag(ptr, &tag);
switch (tag >> 3) {
// string type_url = 1;
case 1:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
auto str = _internal_mutable_type_url();
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "google.protobuf.Any.type_url"));
ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
CHK_(ptr);
CHK_(::_pbi::VerifyUTF8(str, "google.protobuf.Any.type_url"));
} else
goto handle_unusual;
continue;
@ -195,7 +213,7 @@ const char* Any::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::intern
case 2:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
auto str = _internal_mutable_value();
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
CHK_(ptr);
} else
goto handle_unusual;
@ -246,7 +264,7 @@ uint8_t* Any::_InternalSerialize(
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
target = ::_pbi::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:google.protobuf.Any)
@ -275,35 +293,31 @@ size_t Any::ByteSizeLong() const {
this->_internal_value());
}
return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Any::_class_data_ = {
::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
Any::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Any::GetClassData() const { return &_class_data_; }
void Any::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
const ::PROTOBUF_NAMESPACE_ID::Message& from) {
static_cast<Any *>(to)->MergeFrom(
static_cast<const Any &>(from));
}
void Any::MergeFrom(const Any& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.Any)
GOOGLE_DCHECK_NE(&from, this);
void Any::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
auto* const _this = static_cast<Any*>(&to_msg);
auto& from = static_cast<const Any&>(from_msg);
// @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.Any)
GOOGLE_DCHECK_NE(&from, _this);
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
if (!from._internal_type_url().empty()) {
_internal_set_type_url(from._internal_type_url());
_this->_internal_set_type_url(from._internal_type_url());
}
if (!from._internal_value().empty()) {
_internal_set_value(from._internal_value());
_this->_internal_set_value(from._internal_value());
}
_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
_this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}
void Any::CopyFrom(const Any& from) {
@ -323,19 +337,17 @@ void Any::InternalSwap(Any* other) {
auto* rhs_arena = other->GetArenaForAllocation();
_internal_metadata_.InternalSwap(&other->_internal_metadata_);
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
&type_url_, lhs_arena,
&other->type_url_, rhs_arena
&_impl_.type_url_, lhs_arena,
&other->_impl_.type_url_, rhs_arena
);
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
&value_, lhs_arena,
&other->value_, rhs_arena
&_impl_.value_, lhs_arena,
&other->_impl_.value_, rhs_arena
);
}
::PROTOBUF_NAMESPACE_ID::Metadata Any::GetMetadata() const {
return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
return ::_pbi::AssignDescriptors(
&descriptor_table_google_2fprotobuf_2fany_2eproto_getter, &descriptor_table_google_2fprotobuf_2fany_2eproto_once,
file_level_metadata_google_2fprotobuf_2fany_2eproto[0]);
}
@ -343,10 +355,14 @@ void Any::InternalSwap(Any* other) {
// @@protoc_insertion_point(namespace_scope)
PROTOBUF_NAMESPACE_CLOSE
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::PROTOBUF_NAMESPACE_ID::Any* Arena::CreateMaybeMessage< ::PROTOBUF_NAMESPACE_ID::Any >(Arena* arena) {
template<> PROTOBUF_NOINLINE ::PROTOBUF_NAMESPACE_ID::Any*
Arena::CreateMaybeMessage< ::PROTOBUF_NAMESPACE_ID::Any >(Arena* arena) {
return Arena::CreateMessageInternal< ::PROTOBUF_NAMESPACE_ID::Any >(arena);
}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#if defined(__llvm__)
#pragma clang diagnostic pop
#endif // __llvm__
#include <thirdparty/protobuf/port_undef.inc>

93
r5dev/thirdparty/protobuf/any.pb.h vendored
View File

@ -8,12 +8,12 @@
#include <string>
#include <thirdparty/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3019000
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3019004 < PROTOBUF_MIN_PROTOC_VERSION
#if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
@ -23,7 +23,6 @@
#include <thirdparty/protobuf/io/coded_stream.h>
#include <thirdparty/protobuf/arena.h>
#include <thirdparty/protobuf/arenastring.h>
#include <thirdparty/protobuf/generated_message_table_driven.h>
#include <thirdparty/protobuf/generated_message_util.h>
#include <thirdparty/protobuf/metadata_lite.h>
#include <thirdparty/protobuf/generated_message_reflection.h>
@ -42,14 +41,6 @@ PROTOBUF_NAMESPACE_CLOSE
// Internal implementation detail -- do not use these members.
struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fany_2eproto {
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
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[1]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
static const uint32_t offsets[];
};
PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fany_2eproto;
@ -70,7 +61,7 @@ class PROTOBUF_EXPORT Any final :
public:
inline Any() : Any(nullptr) {}
~Any() override;
explicit constexpr Any(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
explicit PROTOBUF_CONSTEXPR Any(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
Any(const Any& from);
Any(Any&& from) noexcept
@ -118,14 +109,16 @@ class PROTOBUF_EXPORT Any final :
// implements Any -----------------------------------------------
bool PackFrom(const ::PROTOBUF_NAMESPACE_ID::Message& message) {
return _any_metadata_.PackFrom(GetArena(), message);
GOOGLE_DCHECK_NE(&message, this);
return _impl_._any_metadata_.PackFrom(GetArena(), message);
}
bool PackFrom(const ::PROTOBUF_NAMESPACE_ID::Message& message,
::PROTOBUF_NAMESPACE_ID::ConstStringParam type_url_prefix) {
return _any_metadata_.PackFrom(GetArena(), message, type_url_prefix);
GOOGLE_DCHECK_NE(&message, this);
return _impl_._any_metadata_.PackFrom(GetArena(), message, type_url_prefix);
}
bool UnpackTo(::PROTOBUF_NAMESPACE_ID::Message* message) const {
return _any_metadata_.UnpackTo(message);
return _impl_._any_metadata_.UnpackTo(message);
}
static bool GetAnyFieldDescriptors(
const ::PROTOBUF_NAMESPACE_ID::Message& message,
@ -133,18 +126,18 @@ class PROTOBUF_EXPORT Any final :
const ::PROTOBUF_NAMESPACE_ID::FieldDescriptor** value_field);
template <typename T, class = typename std::enable_if<!std::is_convertible<T, const ::PROTOBUF_NAMESPACE_ID::Message&>::value>::type>
bool PackFrom(const T& message) {
return _any_metadata_.PackFrom<T>(GetArena(), message);
return _impl_._any_metadata_.PackFrom<T>(GetArena(), message);
}
template <typename T, class = typename std::enable_if<!std::is_convertible<T, const ::PROTOBUF_NAMESPACE_ID::Message&>::value>::type>
bool PackFrom(const T& message,
::PROTOBUF_NAMESPACE_ID::ConstStringParam type_url_prefix) {
return _any_metadata_.PackFrom<T>(GetArena(), message, type_url_prefix);}
return _impl_._any_metadata_.PackFrom<T>(GetArena(), message, type_url_prefix);}
template <typename T, class = typename std::enable_if<!std::is_convertible<T, const ::PROTOBUF_NAMESPACE_ID::Message&>::value>::type>
bool UnpackTo(T* message) const {
return _any_metadata_.UnpackTo<T>(message);
return _impl_._any_metadata_.UnpackTo<T>(message);
}
template<typename T> bool Is() const {
return _any_metadata_.Is<T>();
return _impl_._any_metadata_.Is<T>();
}
static bool ParseAnyTypeUrl(::PROTOBUF_NAMESPACE_ID::ConstStringParam type_url,
std::string* full_type_name);
@ -178,9 +171,11 @@ class PROTOBUF_EXPORT Any final :
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const Any& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const Any& from);
void MergeFrom( const Any& from) {
Any::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
@ -189,10 +184,10 @@ class PROTOBUF_EXPORT Any final :
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor();
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(Any* other);
@ -205,9 +200,6 @@ class PROTOBUF_EXPORT Any final :
protected:
explicit Any(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
@ -258,10 +250,13 @@ class PROTOBUF_EXPORT Any final :
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_url_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata _any_metadata_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_url_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata _any_metadata_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fany_2eproto;
};
// ===================================================================
@ -277,7 +272,7 @@ class PROTOBUF_EXPORT Any final :
// string type_url = 1;
inline void Any::clear_type_url() {
type_url_.ClearToEmpty();
_impl_.type_url_.ClearToEmpty();
}
inline const std::string& Any::type_url() const {
// @@protoc_insertion_point(field_get:google.protobuf.Any.type_url)
@ -287,7 +282,7 @@ template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Any::set_type_url(ArgT0&& arg0, ArgT... args) {
type_url_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
_impl_.type_url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:google.protobuf.Any.type_url)
}
inline std::string* Any::mutable_type_url() {
@ -296,19 +291,19 @@ inline std::string* Any::mutable_type_url() {
return _s;
}
inline const std::string& Any::_internal_type_url() const {
return type_url_.Get();
return _impl_.type_url_.Get();
}
inline void Any::_internal_set_type_url(const std::string& value) {
type_url_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
_impl_.type_url_.Set(value, GetArenaForAllocation());
}
inline std::string* Any::_internal_mutable_type_url() {
return type_url_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
return _impl_.type_url_.Mutable(GetArenaForAllocation());
}
inline std::string* Any::release_type_url() {
// @@protoc_insertion_point(field_release:google.protobuf.Any.type_url)
return type_url_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
return _impl_.type_url_.Release();
}
inline void Any::set_allocated_type_url(std::string* type_url) {
if (type_url != nullptr) {
@ -316,11 +311,10 @@ inline void Any::set_allocated_type_url(std::string* type_url) {
} else {
}
type_url_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), type_url,
GetArenaForAllocation());
_impl_.type_url_.SetAllocated(type_url, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (type_url_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
type_url_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
if (_impl_.type_url_.IsDefault()) {
_impl_.type_url_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:google.protobuf.Any.type_url)
@ -328,7 +322,7 @@ inline void Any::set_allocated_type_url(std::string* type_url) {
// bytes value = 2;
inline void Any::clear_value() {
value_.ClearToEmpty();
_impl_.value_.ClearToEmpty();
}
inline const std::string& Any::value() const {
// @@protoc_insertion_point(field_get:google.protobuf.Any.value)
@ -338,7 +332,7 @@ template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Any::set_value(ArgT0&& arg0, ArgT... args) {
value_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
_impl_.value_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:google.protobuf.Any.value)
}
inline std::string* Any::mutable_value() {
@ -347,19 +341,19 @@ inline std::string* Any::mutable_value() {
return _s;
}
inline const std::string& Any::_internal_value() const {
return value_.Get();
return _impl_.value_.Get();
}
inline void Any::_internal_set_value(const std::string& value) {
value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
_impl_.value_.Set(value, GetArenaForAllocation());
}
inline std::string* Any::_internal_mutable_value() {
return value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
return _impl_.value_.Mutable(GetArenaForAllocation());
}
inline std::string* Any::release_value() {
// @@protoc_insertion_point(field_release:google.protobuf.Any.value)
return value_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
return _impl_.value_.Release();
}
inline void Any::set_allocated_value(std::string* value) {
if (value != nullptr) {
@ -367,11 +361,10 @@ inline void Any::set_allocated_value(std::string* value) {
} else {
}
value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value,
GetArenaForAllocation());
_impl_.value_.SetAllocated(value, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (value_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
if (_impl_.value_.IsDefault()) {
_impl_.value_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:google.protobuf.Any.value)

6
r5dev/thirdparty/protobuf/any.proto vendored
View File

@ -64,7 +64,7 @@ option objc_class_prefix = "GPB";
// foo = any.unpack(Foo.class);
// }
//
// Example 3: Pack and unpack a message in Python.
// Example 3: Pack and unpack a message in Python.
//
// foo = Foo(...)
// any = Any()
@ -74,7 +74,7 @@ option objc_class_prefix = "GPB";
// any.Unpack(foo)
// ...
//
// Example 4: Pack and unpack a message in Go
// Example 4: Pack and unpack a message in Go
//
// foo := &pb.Foo{...}
// any, err := anypb.New(foo)
@ -95,7 +95,7 @@ option objc_class_prefix = "GPB";
//
//
// JSON
// ====
//
// The JSON representation of an `Any` value uses the regular
// representation of the deserialized, embedded message, with an
// additional field `@type` which contains the type URL. Example:

11
r5dev/thirdparty/protobuf/any_lite.cc vendored
View File

@ -28,12 +28,11 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <thirdparty/protobuf/any.h>
#include <thirdparty/protobuf/io/zero_copy_stream_impl_lite.h>
#include <thirdparty/protobuf/stubs/strutil.h>
#include <thirdparty/protobuf/any.h>
#include <thirdparty/protobuf/arenastring.h>
#include <thirdparty/protobuf/generated_message_util.h>
#include <thirdparty/protobuf/stubs/strutil.h>
namespace google {
namespace protobuf {
@ -56,10 +55,8 @@ const char kTypeGoogleProdComPrefix[] = "type.googleprod.com/";
bool AnyMetadata::InternalPackFrom(Arena* arena, const MessageLite& message,
StringPiece type_url_prefix,
StringPiece type_name) {
type_url_->Set(&::google::protobuf::internal::GetEmptyString(),
GetTypeUrl(type_name, type_url_prefix), arena);
return message.SerializeToString(
value_->Mutable(ArenaStringPtr::EmptyDefault{}, arena));
type_url_->Set(GetTypeUrl(type_name, type_url_prefix), arena);
return message.SerializeToString(value_->Mutable(arena));
}
bool AnyMetadata::InternalUnpackTo(StringPiece type_name,

10
r5dev/thirdparty/protobuf/any_test.cc vendored
View File

@ -176,6 +176,16 @@ TEST(AnyTest, MoveAssignment) {
EXPECT_EQ(12345, payload.int32_value());
}
#ifdef PROTOBUF_HAS_DEATH_TEST
#ifndef NDEBUG
TEST(AnyTest, PackSelfDeath) {
google::protobuf::Any any;
EXPECT_DEATH(any.PackFrom(any), "&message");
EXPECT_DEATH(any.PackFrom(any, ""), "&message");
}
#endif // !NDEBUG
#endif // PROTOBUF_HAS_DEATH_TEST
} // namespace
} // namespace protobuf

760
r5dev/thirdparty/protobuf/api.pb.cc vendored
View File

File diff suppressed because it is too large Load Diff

343
r5dev/thirdparty/protobuf/api.pb.h vendored
View File

@ -8,12 +8,12 @@
#include <string>
#include <thirdparty/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3019000
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3019004 < PROTOBUF_MIN_PROTOC_VERSION
#if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
@ -23,7 +23,6 @@
#include <thirdparty/protobuf/io/coded_stream.h>
#include <thirdparty/protobuf/arena.h>
#include <thirdparty/protobuf/arenastring.h>
#include <thirdparty/protobuf/generated_message_table_driven.h>
#include <thirdparty/protobuf/generated_message_util.h>
#include <thirdparty/protobuf/metadata_lite.h>
#include <thirdparty/protobuf/generated_message_reflection.h>
@ -44,14 +43,6 @@ PROTOBUF_NAMESPACE_CLOSE
// Internal implementation detail -- do not use these members.
struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fapi_2eproto {
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
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[3]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
static const uint32_t offsets[];
};
PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fapi_2eproto;
@ -80,7 +71,7 @@ class PROTOBUF_EXPORT Api final :
public:
inline Api() : Api(nullptr) {}
~Api() override;
explicit constexpr Api(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
explicit PROTOBUF_CONSTEXPR Api(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
Api(const Api& from);
Api(Api&& from) noexcept
@ -155,9 +146,11 @@ class PROTOBUF_EXPORT Api final :
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const Api& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const Api& from);
void MergeFrom( const Api& from) {
Api::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
@ -166,10 +159,10 @@ class PROTOBUF_EXPORT Api final :
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor();
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(Api* other);
@ -182,9 +175,6 @@ class PROTOBUF_EXPORT Api final :
protected:
explicit Api(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
@ -321,14 +311,17 @@ class PROTOBUF_EXPORT Api final :
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Method > methods_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option > options_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Mixin > mixins_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
::PROTOBUF_NAMESPACE_ID::SourceContext* source_context_;
int syntax_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Method > methods_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option > options_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Mixin > mixins_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
::PROTOBUF_NAMESPACE_ID::SourceContext* source_context_;
int syntax_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fapi_2eproto;
};
// -------------------------------------------------------------------
@ -338,7 +331,7 @@ class PROTOBUF_EXPORT Method final :
public:
inline Method() : Method(nullptr) {}
~Method() override;
explicit constexpr Method(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
explicit PROTOBUF_CONSTEXPR Method(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
Method(const Method& from);
Method(Method&& from) noexcept
@ -413,9 +406,11 @@ class PROTOBUF_EXPORT Method final :
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const Method& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const Method& from);
void MergeFrom( const Method& from) {
Method::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
@ -424,10 +419,10 @@ class PROTOBUF_EXPORT Method final :
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor();
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(Method* other);
@ -440,9 +435,6 @@ class PROTOBUF_EXPORT Method final :
protected:
explicit Method(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
@ -557,14 +549,17 @@ class PROTOBUF_EXPORT Method final :
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option > options_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_type_url_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr response_type_url_;
bool request_streaming_;
bool response_streaming_;
int syntax_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option > options_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_type_url_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr response_type_url_;
bool request_streaming_;
bool response_streaming_;
int syntax_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fapi_2eproto;
};
// -------------------------------------------------------------------
@ -574,7 +569,7 @@ class PROTOBUF_EXPORT Mixin final :
public:
inline Mixin() : Mixin(nullptr) {}
~Mixin() override;
explicit constexpr Mixin(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
explicit PROTOBUF_CONSTEXPR Mixin(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
Mixin(const Mixin& from);
Mixin(Mixin&& from) noexcept
@ -649,9 +644,11 @@ class PROTOBUF_EXPORT Mixin final :
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const Mixin& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const Mixin& from);
void MergeFrom( const Mixin& from) {
Mixin::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
@ -660,10 +657,10 @@ class PROTOBUF_EXPORT Mixin final :
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor();
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(Mixin* other);
@ -676,9 +673,6 @@ class PROTOBUF_EXPORT Mixin final :
protected:
explicit Mixin(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
@ -729,9 +723,12 @@ class PROTOBUF_EXPORT Mixin final :
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr root_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr root_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fapi_2eproto;
};
// ===================================================================
@ -747,7 +744,7 @@ class PROTOBUF_EXPORT Mixin final :
// string name = 1;
inline void Api::clear_name() {
name_.ClearToEmpty();
_impl_.name_.ClearToEmpty();
}
inline const std::string& Api::name() const {
// @@protoc_insertion_point(field_get:google.protobuf.Api.name)
@ -757,7 +754,7 @@ template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Api::set_name(ArgT0&& arg0, ArgT... args) {
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
_impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:google.protobuf.Api.name)
}
inline std::string* Api::mutable_name() {
@ -766,19 +763,19 @@ inline std::string* Api::mutable_name() {
return _s;
}
inline const std::string& Api::_internal_name() const {
return name_.Get();
return _impl_.name_.Get();
}
inline void Api::_internal_set_name(const std::string& value) {
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
_impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* Api::_internal_mutable_name() {
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* Api::release_name() {
// @@protoc_insertion_point(field_release:google.protobuf.Api.name)
return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
return _impl_.name_.Release();
}
inline void Api::set_allocated_name(std::string* name) {
if (name != nullptr) {
@ -786,11 +783,10 @@ inline void Api::set_allocated_name(std::string* name) {
} else {
}
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
GetArenaForAllocation());
_impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
if (_impl_.name_.IsDefault()) {
_impl_.name_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:google.protobuf.Api.name)
@ -798,32 +794,32 @@ inline void Api::set_allocated_name(std::string* name) {
// repeated .google.protobuf.Method methods = 2;
inline int Api::_internal_methods_size() const {
return methods_.size();
return _impl_.methods_.size();
}
inline int Api::methods_size() const {
return _internal_methods_size();
}
inline void Api::clear_methods() {
methods_.Clear();
_impl_.methods_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::Method* Api::mutable_methods(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.Api.methods)
return methods_.Mutable(index);
return _impl_.methods_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Method >*
Api::mutable_methods() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.Api.methods)
return &methods_;
return &_impl_.methods_;
}
inline const ::PROTOBUF_NAMESPACE_ID::Method& Api::_internal_methods(int index) const {
return methods_.Get(index);
return _impl_.methods_.Get(index);
}
inline const ::PROTOBUF_NAMESPACE_ID::Method& Api::methods(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.Api.methods)
return _internal_methods(index);
}
inline ::PROTOBUF_NAMESPACE_ID::Method* Api::_internal_add_methods() {
return methods_.Add();
return _impl_.methods_.Add();
}
inline ::PROTOBUF_NAMESPACE_ID::Method* Api::add_methods() {
::PROTOBUF_NAMESPACE_ID::Method* _add = _internal_add_methods();
@ -833,34 +829,34 @@ inline ::PROTOBUF_NAMESPACE_ID::Method* Api::add_methods() {
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Method >&
Api::methods() const {
// @@protoc_insertion_point(field_list:google.protobuf.Api.methods)
return methods_;
return _impl_.methods_;
}
// repeated .google.protobuf.Option options = 3;
inline int Api::_internal_options_size() const {
return options_.size();
return _impl_.options_.size();
}
inline int Api::options_size() const {
return _internal_options_size();
}
inline ::PROTOBUF_NAMESPACE_ID::Option* Api::mutable_options(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.Api.options)
return options_.Mutable(index);
return _impl_.options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >*
Api::mutable_options() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.Api.options)
return &options_;
return &_impl_.options_;
}
inline const ::PROTOBUF_NAMESPACE_ID::Option& Api::_internal_options(int index) const {
return options_.Get(index);
return _impl_.options_.Get(index);
}
inline const ::PROTOBUF_NAMESPACE_ID::Option& Api::options(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.Api.options)
return _internal_options(index);
}
inline ::PROTOBUF_NAMESPACE_ID::Option* Api::_internal_add_options() {
return options_.Add();
return _impl_.options_.Add();
}
inline ::PROTOBUF_NAMESPACE_ID::Option* Api::add_options() {
::PROTOBUF_NAMESPACE_ID::Option* _add = _internal_add_options();
@ -870,12 +866,12 @@ inline ::PROTOBUF_NAMESPACE_ID::Option* Api::add_options() {
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >&
Api::options() const {
// @@protoc_insertion_point(field_list:google.protobuf.Api.options)
return options_;
return _impl_.options_;
}
// string version = 4;
inline void Api::clear_version() {
version_.ClearToEmpty();
_impl_.version_.ClearToEmpty();
}
inline const std::string& Api::version() const {
// @@protoc_insertion_point(field_get:google.protobuf.Api.version)
@ -885,7 +881,7 @@ template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Api::set_version(ArgT0&& arg0, ArgT... args) {
version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
_impl_.version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:google.protobuf.Api.version)
}
inline std::string* Api::mutable_version() {
@ -894,19 +890,19 @@ inline std::string* Api::mutable_version() {
return _s;
}
inline const std::string& Api::_internal_version() const {
return version_.Get();
return _impl_.version_.Get();
}
inline void Api::_internal_set_version(const std::string& value) {
version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
_impl_.version_.Set(value, GetArenaForAllocation());
}
inline std::string* Api::_internal_mutable_version() {
return version_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
return _impl_.version_.Mutable(GetArenaForAllocation());
}
inline std::string* Api::release_version() {
// @@protoc_insertion_point(field_release:google.protobuf.Api.version)
return version_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
return _impl_.version_.Release();
}
inline void Api::set_allocated_version(std::string* version) {
if (version != nullptr) {
@ -914,11 +910,10 @@ inline void Api::set_allocated_version(std::string* version) {
} else {
}
version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), version,
GetArenaForAllocation());
_impl_.version_.SetAllocated(version, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (version_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
if (_impl_.version_.IsDefault()) {
_impl_.version_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:google.protobuf.Api.version)
@ -926,13 +921,13 @@ inline void Api::set_allocated_version(std::string* version) {
// .google.protobuf.SourceContext source_context = 5;
inline bool Api::_internal_has_source_context() const {
return this != internal_default_instance() && source_context_ != nullptr;
return this != internal_default_instance() && _impl_.source_context_ != nullptr;
}
inline bool Api::has_source_context() const {
return _internal_has_source_context();
}
inline const ::PROTOBUF_NAMESPACE_ID::SourceContext& Api::_internal_source_context() const {
const ::PROTOBUF_NAMESPACE_ID::SourceContext* p = source_context_;
const ::PROTOBUF_NAMESPACE_ID::SourceContext* p = _impl_.source_context_;
return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::SourceContext&>(
::PROTOBUF_NAMESPACE_ID::_SourceContext_default_instance_);
}
@ -943,9 +938,9 @@ inline const ::PROTOBUF_NAMESPACE_ID::SourceContext& Api::source_context() const
inline void Api::unsafe_arena_set_allocated_source_context(
::PROTOBUF_NAMESPACE_ID::SourceContext* source_context) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(source_context_);
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_context_);
}
source_context_ = source_context;
_impl_.source_context_ = source_context;
if (source_context) {
} else {
@ -955,8 +950,8 @@ inline void Api::unsafe_arena_set_allocated_source_context(
}
inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Api::release_source_context() {
::PROTOBUF_NAMESPACE_ID::SourceContext* temp = source_context_;
source_context_ = nullptr;
::PROTOBUF_NAMESPACE_ID::SourceContext* temp = _impl_.source_context_;
_impl_.source_context_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
@ -971,17 +966,17 @@ inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Api::release_source_context() {
inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Api::unsafe_arena_release_source_context() {
// @@protoc_insertion_point(field_release:google.protobuf.Api.source_context)
::PROTOBUF_NAMESPACE_ID::SourceContext* temp = source_context_;
source_context_ = nullptr;
::PROTOBUF_NAMESPACE_ID::SourceContext* temp = _impl_.source_context_;
_impl_.source_context_ = nullptr;
return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Api::_internal_mutable_source_context() {
if (source_context_ == nullptr) {
if (_impl_.source_context_ == nullptr) {
auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::SourceContext>(GetArenaForAllocation());
source_context_ = p;
_impl_.source_context_ = p;
}
return source_context_;
return _impl_.source_context_;
}
inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Api::mutable_source_context() {
::PROTOBUF_NAMESPACE_ID::SourceContext* _msg = _internal_mutable_source_context();
@ -991,12 +986,11 @@ inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Api::mutable_source_context() {
inline void Api::set_allocated_source_context(::PROTOBUF_NAMESPACE_ID::SourceContext* source_context) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(source_context_);
delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_context_);
}
if (source_context) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(source_context));
if (message_arena != submessage_arena) {
source_context = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
@ -1006,38 +1000,38 @@ inline void Api::set_allocated_source_context(::PROTOBUF_NAMESPACE_ID::SourceCon
} else {
}
source_context_ = source_context;
_impl_.source_context_ = source_context;
// @@protoc_insertion_point(field_set_allocated:google.protobuf.Api.source_context)
}
// repeated .google.protobuf.Mixin mixins = 6;
inline int Api::_internal_mixins_size() const {
return mixins_.size();
return _impl_.mixins_.size();
}
inline int Api::mixins_size() const {
return _internal_mixins_size();
}
inline void Api::clear_mixins() {
mixins_.Clear();
_impl_.mixins_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::Mixin* Api::mutable_mixins(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.Api.mixins)
return mixins_.Mutable(index);
return _impl_.mixins_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Mixin >*
Api::mutable_mixins() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.Api.mixins)
return &mixins_;
return &_impl_.mixins_;
}
inline const ::PROTOBUF_NAMESPACE_ID::Mixin& Api::_internal_mixins(int index) const {
return mixins_.Get(index);
return _impl_.mixins_.Get(index);
}
inline const ::PROTOBUF_NAMESPACE_ID::Mixin& Api::mixins(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.Api.mixins)
return _internal_mixins(index);
}
inline ::PROTOBUF_NAMESPACE_ID::Mixin* Api::_internal_add_mixins() {
return mixins_.Add();
return _impl_.mixins_.Add();
}
inline ::PROTOBUF_NAMESPACE_ID::Mixin* Api::add_mixins() {
::PROTOBUF_NAMESPACE_ID::Mixin* _add = _internal_add_mixins();
@ -1047,15 +1041,15 @@ inline ::PROTOBUF_NAMESPACE_ID::Mixin* Api::add_mixins() {
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Mixin >&
Api::mixins() const {
// @@protoc_insertion_point(field_list:google.protobuf.Api.mixins)
return mixins_;
return _impl_.mixins_;
}
// .google.protobuf.Syntax syntax = 7;
inline void Api::clear_syntax() {
syntax_ = 0;
_impl_.syntax_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::Syntax Api::_internal_syntax() const {
return static_cast< ::PROTOBUF_NAMESPACE_ID::Syntax >(syntax_);
return static_cast< ::PROTOBUF_NAMESPACE_ID::Syntax >(_impl_.syntax_);
}
inline ::PROTOBUF_NAMESPACE_ID::Syntax Api::syntax() const {
// @@protoc_insertion_point(field_get:google.protobuf.Api.syntax)
@ -1063,7 +1057,7 @@ inline ::PROTOBUF_NAMESPACE_ID::Syntax Api::syntax() const {
}
inline void Api::_internal_set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value) {
syntax_ = value;
_impl_.syntax_ = value;
}
inline void Api::set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value) {
_internal_set_syntax(value);
@ -1076,7 +1070,7 @@ inline void Api::set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value) {
// string name = 1;
inline void Method::clear_name() {
name_.ClearToEmpty();
_impl_.name_.ClearToEmpty();
}
inline const std::string& Method::name() const {
// @@protoc_insertion_point(field_get:google.protobuf.Method.name)
@ -1086,7 +1080,7 @@ template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Method::set_name(ArgT0&& arg0, ArgT... args) {
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
_impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:google.protobuf.Method.name)
}
inline std::string* Method::mutable_name() {
@ -1095,19 +1089,19 @@ inline std::string* Method::mutable_name() {
return _s;
}
inline const std::string& Method::_internal_name() const {
return name_.Get();
return _impl_.name_.Get();
}
inline void Method::_internal_set_name(const std::string& value) {
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
_impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* Method::_internal_mutable_name() {
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* Method::release_name() {
// @@protoc_insertion_point(field_release:google.protobuf.Method.name)
return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
return _impl_.name_.Release();
}
inline void Method::set_allocated_name(std::string* name) {
if (name != nullptr) {
@ -1115,11 +1109,10 @@ inline void Method::set_allocated_name(std::string* name) {
} else {
}
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
GetArenaForAllocation());
_impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
if (_impl_.name_.IsDefault()) {
_impl_.name_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:google.protobuf.Method.name)
@ -1127,7 +1120,7 @@ inline void Method::set_allocated_name(std::string* name) {
// string request_type_url = 2;
inline void Method::clear_request_type_url() {
request_type_url_.ClearToEmpty();
_impl_.request_type_url_.ClearToEmpty();
}
inline const std::string& Method::request_type_url() const {
// @@protoc_insertion_point(field_get:google.protobuf.Method.request_type_url)
@ -1137,7 +1130,7 @@ template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Method::set_request_type_url(ArgT0&& arg0, ArgT... args) {
request_type_url_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
_impl_.request_type_url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:google.protobuf.Method.request_type_url)
}
inline std::string* Method::mutable_request_type_url() {
@ -1146,19 +1139,19 @@ inline std::string* Method::mutable_request_type_url() {
return _s;
}
inline const std::string& Method::_internal_request_type_url() const {
return request_type_url_.Get();
return _impl_.request_type_url_.Get();
}
inline void Method::_internal_set_request_type_url(const std::string& value) {
request_type_url_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
_impl_.request_type_url_.Set(value, GetArenaForAllocation());
}
inline std::string* Method::_internal_mutable_request_type_url() {
return request_type_url_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
return _impl_.request_type_url_.Mutable(GetArenaForAllocation());
}
inline std::string* Method::release_request_type_url() {
// @@protoc_insertion_point(field_release:google.protobuf.Method.request_type_url)
return request_type_url_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
return _impl_.request_type_url_.Release();
}
inline void Method::set_allocated_request_type_url(std::string* request_type_url) {
if (request_type_url != nullptr) {
@ -1166,11 +1159,10 @@ inline void Method::set_allocated_request_type_url(std::string* request_type_url
} else {
}
request_type_url_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), request_type_url,
GetArenaForAllocation());
_impl_.request_type_url_.SetAllocated(request_type_url, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (request_type_url_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
request_type_url_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
if (_impl_.request_type_url_.IsDefault()) {
_impl_.request_type_url_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:google.protobuf.Method.request_type_url)
@ -1178,10 +1170,10 @@ inline void Method::set_allocated_request_type_url(std::string* request_type_url
// bool request_streaming = 3;
inline void Method::clear_request_streaming() {
request_streaming_ = false;
_impl_.request_streaming_ = false;
}
inline bool Method::_internal_request_streaming() const {
return request_streaming_;
return _impl_.request_streaming_;
}
inline bool Method::request_streaming() const {
// @@protoc_insertion_point(field_get:google.protobuf.Method.request_streaming)
@ -1189,7 +1181,7 @@ inline bool Method::request_streaming() const {
}
inline void Method::_internal_set_request_streaming(bool value) {
request_streaming_ = value;
_impl_.request_streaming_ = value;
}
inline void Method::set_request_streaming(bool value) {
_internal_set_request_streaming(value);
@ -1198,7 +1190,7 @@ inline void Method::set_request_streaming(bool value) {
// string response_type_url = 4;
inline void Method::clear_response_type_url() {
response_type_url_.ClearToEmpty();
_impl_.response_type_url_.ClearToEmpty();
}
inline const std::string& Method::response_type_url() const {
// @@protoc_insertion_point(field_get:google.protobuf.Method.response_type_url)
@ -1208,7 +1200,7 @@ template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Method::set_response_type_url(ArgT0&& arg0, ArgT... args) {
response_type_url_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
_impl_.response_type_url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:google.protobuf.Method.response_type_url)
}
inline std::string* Method::mutable_response_type_url() {
@ -1217,19 +1209,19 @@ inline std::string* Method::mutable_response_type_url() {
return _s;
}
inline const std::string& Method::_internal_response_type_url() const {
return response_type_url_.Get();
return _impl_.response_type_url_.Get();
}
inline void Method::_internal_set_response_type_url(const std::string& value) {
response_type_url_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
_impl_.response_type_url_.Set(value, GetArenaForAllocation());
}
inline std::string* Method::_internal_mutable_response_type_url() {
return response_type_url_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
return _impl_.response_type_url_.Mutable(GetArenaForAllocation());
}
inline std::string* Method::release_response_type_url() {
// @@protoc_insertion_point(field_release:google.protobuf.Method.response_type_url)
return response_type_url_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
return _impl_.response_type_url_.Release();
}
inline void Method::set_allocated_response_type_url(std::string* response_type_url) {
if (response_type_url != nullptr) {
@ -1237,11 +1229,10 @@ inline void Method::set_allocated_response_type_url(std::string* response_type_u
} else {
}
response_type_url_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), response_type_url,
GetArenaForAllocation());
_impl_.response_type_url_.SetAllocated(response_type_url, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (response_type_url_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
response_type_url_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
if (_impl_.response_type_url_.IsDefault()) {
_impl_.response_type_url_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:google.protobuf.Method.response_type_url)
@ -1249,10 +1240,10 @@ inline void Method::set_allocated_response_type_url(std::string* response_type_u
// bool response_streaming = 5;
inline void Method::clear_response_streaming() {
response_streaming_ = false;
_impl_.response_streaming_ = false;
}
inline bool Method::_internal_response_streaming() const {
return response_streaming_;
return _impl_.response_streaming_;
}
inline bool Method::response_streaming() const {
// @@protoc_insertion_point(field_get:google.protobuf.Method.response_streaming)
@ -1260,7 +1251,7 @@ inline bool Method::response_streaming() const {
}
inline void Method::_internal_set_response_streaming(bool value) {
response_streaming_ = value;
_impl_.response_streaming_ = value;
}
inline void Method::set_response_streaming(bool value) {
_internal_set_response_streaming(value);
@ -1269,29 +1260,29 @@ inline void Method::set_response_streaming(bool value) {
// repeated .google.protobuf.Option options = 6;
inline int Method::_internal_options_size() const {
return options_.size();
return _impl_.options_.size();
}
inline int Method::options_size() const {
return _internal_options_size();
}
inline ::PROTOBUF_NAMESPACE_ID::Option* Method::mutable_options(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.Method.options)
return options_.Mutable(index);
return _impl_.options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >*
Method::mutable_options() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.Method.options)
return &options_;
return &_impl_.options_;
}
inline const ::PROTOBUF_NAMESPACE_ID::Option& Method::_internal_options(int index) const {
return options_.Get(index);
return _impl_.options_.Get(index);
}
inline const ::PROTOBUF_NAMESPACE_ID::Option& Method::options(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.Method.options)
return _internal_options(index);
}
inline ::PROTOBUF_NAMESPACE_ID::Option* Method::_internal_add_options() {
return options_.Add();
return _impl_.options_.Add();
}
inline ::PROTOBUF_NAMESPACE_ID::Option* Method::add_options() {
::PROTOBUF_NAMESPACE_ID::Option* _add = _internal_add_options();
@ -1301,15 +1292,15 @@ inline ::PROTOBUF_NAMESPACE_ID::Option* Method::add_options() {
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >&
Method::options() const {
// @@protoc_insertion_point(field_list:google.protobuf.Method.options)
return options_;
return _impl_.options_;
}
// .google.protobuf.Syntax syntax = 7;
inline void Method::clear_syntax() {
syntax_ = 0;
_impl_.syntax_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::Syntax Method::_internal_syntax() const {
return static_cast< ::PROTOBUF_NAMESPACE_ID::Syntax >(syntax_);
return static_cast< ::PROTOBUF_NAMESPACE_ID::Syntax >(_impl_.syntax_);
}
inline ::PROTOBUF_NAMESPACE_ID::Syntax Method::syntax() const {
// @@protoc_insertion_point(field_get:google.protobuf.Method.syntax)
@ -1317,7 +1308,7 @@ inline ::PROTOBUF_NAMESPACE_ID::Syntax Method::syntax() const {
}
inline void Method::_internal_set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value) {
syntax_ = value;
_impl_.syntax_ = value;
}
inline void Method::set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value) {
_internal_set_syntax(value);
@ -1330,7 +1321,7 @@ inline void Method::set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value) {
// string name = 1;
inline void Mixin::clear_name() {
name_.ClearToEmpty();
_impl_.name_.ClearToEmpty();
}
inline const std::string& Mixin::name() const {
// @@protoc_insertion_point(field_get:google.protobuf.Mixin.name)
@ -1340,7 +1331,7 @@ template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Mixin::set_name(ArgT0&& arg0, ArgT... args) {
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
_impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:google.protobuf.Mixin.name)
}
inline std::string* Mixin::mutable_name() {
@ -1349,19 +1340,19 @@ inline std::string* Mixin::mutable_name() {
return _s;
}
inline const std::string& Mixin::_internal_name() const {
return name_.Get();
return _impl_.name_.Get();
}
inline void Mixin::_internal_set_name(const std::string& value) {
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
_impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* Mixin::_internal_mutable_name() {
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* Mixin::release_name() {
// @@protoc_insertion_point(field_release:google.protobuf.Mixin.name)
return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
return _impl_.name_.Release();
}
inline void Mixin::set_allocated_name(std::string* name) {
if (name != nullptr) {
@ -1369,11 +1360,10 @@ inline void Mixin::set_allocated_name(std::string* name) {
} else {
}
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
GetArenaForAllocation());
_impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
if (_impl_.name_.IsDefault()) {
_impl_.name_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:google.protobuf.Mixin.name)
@ -1381,7 +1371,7 @@ inline void Mixin::set_allocated_name(std::string* name) {
// string root = 2;
inline void Mixin::clear_root() {
root_.ClearToEmpty();
_impl_.root_.ClearToEmpty();
}
inline const std::string& Mixin::root() const {
// @@protoc_insertion_point(field_get:google.protobuf.Mixin.root)
@ -1391,7 +1381,7 @@ template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Mixin::set_root(ArgT0&& arg0, ArgT... args) {
root_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
_impl_.root_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:google.protobuf.Mixin.root)
}
inline std::string* Mixin::mutable_root() {
@ -1400,19 +1390,19 @@ inline std::string* Mixin::mutable_root() {
return _s;
}
inline const std::string& Mixin::_internal_root() const {
return root_.Get();
return _impl_.root_.Get();
}
inline void Mixin::_internal_set_root(const std::string& value) {
root_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
_impl_.root_.Set(value, GetArenaForAllocation());
}
inline std::string* Mixin::_internal_mutable_root() {
return root_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
return _impl_.root_.Mutable(GetArenaForAllocation());
}
inline std::string* Mixin::release_root() {
// @@protoc_insertion_point(field_release:google.protobuf.Mixin.root)
return root_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
return _impl_.root_.Release();
}
inline void Mixin::set_allocated_root(std::string* root) {
if (root != nullptr) {
@ -1420,11 +1410,10 @@ inline void Mixin::set_allocated_root(std::string* root) {
} else {
}
root_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), root,
GetArenaForAllocation());
_impl_.root_.SetAllocated(root, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (root_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
root_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
if (_impl_.root_.IsDefault()) {
_impl_.root_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:google.protobuf.Mixin.root)

50
r5dev/thirdparty/protobuf/arena.cc vendored
View File

@ -38,12 +38,15 @@
#include <typeinfo>
#include <thirdparty/protobuf/arena_impl.h>
#include <thirdparty/protobuf/arenaz_sampler.h>
#include <thirdparty/protobuf/port.h>
#include <thirdparty/protobuf/stubs/mutex.h>
#ifdef ADDRESS_SANITIZER
#include <sanitizer/asan_interface.h>
#endif // ADDRESS_SANITIZER
// Must be included last.
#include <thirdparty/protobuf/port_def.inc>
namespace google {
@ -91,11 +94,7 @@ class GetDeallocator {
if (dealloc_) {
dealloc_(mem.ptr, mem.size);
} else {
#if defined(__GXX_DELETE_WITH_SIZE__) || defined(__cpp_sized_deallocation)
::operator delete(mem.ptr, mem.size);
#else
::operator delete(mem.ptr);
#endif
internal::SizedDelete(mem.ptr, mem.size);
}
*space_allocated_ += mem.size;
}
@ -105,18 +104,22 @@ class GetDeallocator {
size_t* space_allocated_;
};
SerialArena::SerialArena(Block* b, void* owner) : space_allocated_(b->size) {
SerialArena::SerialArena(Block* b, void* owner, ThreadSafeArenaStats* stats)
: space_allocated_(b->size) {
owner_ = owner;
head_ = b;
ptr_ = b->Pointer(kBlockHeaderSize + ThreadSafeArena::kSerialArenaSize);
limit_ = b->Pointer(b->size & static_cast<size_t>(-8));
arena_stats_ = stats;
}
SerialArena* SerialArena::New(Memory mem, void* owner) {
SerialArena* SerialArena::New(Memory mem, void* owner,
ThreadSafeArenaStats* stats) {
GOOGLE_DCHECK_LE(kBlockHeaderSize + ThreadSafeArena::kSerialArenaSize, mem.size);
ThreadSafeArenaStats::RecordAllocateStats(
stats, /*requested=*/mem.size, /*allocated=*/mem.size, /*wasted=*/0);
auto b = new (mem.ptr) Block{nullptr, mem.size};
return new (b->Pointer(kBlockHeaderSize)) SerialArena(b, owner);
return new (b->Pointer(kBlockHeaderSize)) SerialArena(b, owner, stats);
}
template <typename Deallocator>
@ -151,7 +154,14 @@ void SerialArena::AllocateNewBlock(size_t n, const AllocationPolicy* policy) {
head_->start = reinterpret_cast<CleanupNode*>(limit_);
// Record how much used in this block.
space_used_ += ptr_ - head_->Pointer(kBlockHeaderSize);
size_t used = ptr_ - head_->Pointer(kBlockHeaderSize);
size_t wasted = head_->size - used;
space_used_ += used;
// TODO(sbenza): Evaluate if pushing unused space into the cached blocks is a
// win. In preliminary testing showed increased memory savings as expected,
// but with a CPU regression. The regression might have been an artifact of
// the microbenchmark.
auto mem = AllocateMemory(policy, head_->size, n);
// We don't want to emit an expensive RMW instruction that requires
@ -159,6 +169,8 @@ void SerialArena::AllocateNewBlock(size_t n, const AllocationPolicy* policy) {
// regular add.
auto relaxed = std::memory_order_relaxed;
space_allocated_.store(space_allocated_.load(relaxed) + mem.size, relaxed);
ThreadSafeArenaStats::RecordAllocateStats(arena_stats_, /*requested=*/n,
/*allocated=*/mem.size, wasted);
head_ = new (mem.ptr) Block{head_, mem.size};
ptr_ = head_->Pointer(kBlockHeaderSize);
limit_ = head_->Pointer(head_->size);
@ -312,10 +324,12 @@ void ThreadSafeArena::Init() {
#ifndef NDEBUG
GOOGLE_CHECK_EQ(was_message_owned, IsMessageOwned());
#endif // NDEBUG
arena_stats_ = Sample();
}
void ThreadSafeArena::SetInitialBlock(void* mem, size_t size) {
SerialArena* serial = SerialArena::New({mem, size}, &thread_cache());
SerialArena* serial = SerialArena::New({mem, size}, &thread_cache(),
arena_stats_.MutableStats());
serial->set_next(NULL);
threads_.store(serial, std::memory_order_relaxed);
CacheSerialArena(serial);
@ -334,6 +348,10 @@ ThreadSafeArena::~ThreadSafeArena() {
ArenaMetricsCollector* collector = p ? p->metrics_collector : nullptr;
if (alloc_policy_.is_user_owned_initial_block()) {
#ifdef ADDRESS_SANITIZER
// Unpoison the initial block, now that it's going back to the user.
ASAN_UNPOISON_MEMORY_REGION(mem.ptr, mem.size);
#endif // ADDRESS_SANITIZER
space_allocated += mem.size;
} else {
GetDeallocator(alloc_policy_.get(), &space_allocated)(mem);
@ -360,6 +378,7 @@ uint64_t ThreadSafeArena::Reset() {
// Discard all blocks except the special block (if present).
size_t space_allocated = 0;
auto mem = Free(&space_allocated);
arena_stats_.RecordReset();
AllocationPolicy* policy = alloc_policy_.get();
if (policy) {
@ -474,7 +493,8 @@ SerialArena* ThreadSafeArena::GetSerialArenaFallback(void* me) {
// This thread doesn't have any SerialArena, which also means it doesn't
// have any blocks yet. So we'll allocate its first block now.
serial = SerialArena::New(
AllocateMemory(alloc_policy_.get(), 0, kSerialArenaSize), me);
AllocateMemory(alloc_policy_.get(), 0, kSerialArenaSize), me,
arena_stats_.MutableStats());
SerialArena* head = threads_.load(std::memory_order_relaxed);
do {
@ -499,6 +519,12 @@ void* Arena::AllocateAlignedWithHook(size_t n, const std::type_info* type) {
return impl_.AllocateAligned(n, type);
}
PROTOBUF_FUNC_ALIGN(32)
void* Arena::AllocateAlignedWithHookForArray(size_t n,
const std::type_info* type) {
return impl_.AllocateAligned<internal::AllocationClient::kArray>(n, type);
}
PROTOBUF_FUNC_ALIGN(32)
std::pair<void*, internal::SerialArena::CleanupNode*>
Arena::AllocateAlignedWithCleanup(size_t n, const std::type_info* type) {

94
r5dev/thirdparty/protobuf/arena.h vendored
View File

@ -37,9 +37,6 @@
#include <limits>
#include <type_traits>
#include <utility>
#ifdef max
#undef max // Visual Studio defines this macro
#endif
#if defined(_MSC_VER) && !defined(_LIBCPP_STD_VER) && !_HAS_EXCEPTIONS
// Work around bugs in MSVC <typeinfo> header when _HAS_EXCEPTIONS=0.
#include <exception>
@ -55,6 +52,7 @@ using type_info = ::type_info;
#include <thirdparty/protobuf/arena_impl.h>
#include <thirdparty/protobuf/port.h>
// Must be included last.
#include <thirdparty/protobuf/port_def.inc>
#ifdef SWIG
@ -83,10 +81,11 @@ class ReflectionTester; // defined in test_util.h
namespace internal {
struct ArenaStringPtr; // defined in arenastring.h
class InlinedStringField; // defined in inlined_string_field.h
class LazyField; // defined in lazy_field.h
class EpsCopyInputStream; // defined in parse_context.h
struct ArenaTestPeer; // defined in arena_test_util.h
class InternalMetadata; // defined in metadata_lite.h
class LazyField; // defined in lazy_field.h
class EpsCopyInputStream; // defined in parse_context.h
class RepeatedPtrFieldBase; // defined in repeated_ptr_field.h
template <typename Type>
class GenericTypeHandler; // defined in repeated_field.h
@ -316,6 +315,20 @@ class PROTOBUF_EXPORT PROTOBUF_ALIGNAS(8) Arena final {
static_cast<Args&&>(args)...);
}
// Allocates memory with the specific size and alignment.
void* AllocateAligned(size_t size, size_t align = 8) {
if (align <= 8) {
return AllocateAlignedNoHook(internal::AlignUpTo8(size));
} else {
// We are wasting space by over allocating align - 8 bytes. Compared
// to a dedicated function that takes current alignment in consideration.
// Such a scheme would only waste (align - 8)/2 bytes on average, but
// requires a dedicated function in the outline arena allocation
// functions. Possibly re-evaluate tradeoffs later.
return internal::AlignTo(AllocateAlignedNoHook(size + align - 8), align);
}
}
// Create an array of object type T on the arena *without* invoking the
// constructor of T. If `arena` is null, then the return value should be freed
// with `delete[] x;` (or `::operator delete[](x);`).
@ -397,27 +410,12 @@ class PROTOBUF_EXPORT PROTOBUF_ALIGNAS(8) Arena final {
template <typename T>
class InternalHelper {
public:
private:
// Provides access to protected GetOwningArena to generated messages.
static Arena* GetOwningArena(const T* p) { return p->GetOwningArena(); }
// Provides access to protected GetArenaForAllocation to generated messages.
static Arena* GetArenaForAllocation(const T* p) {
return GetArenaForAllocationInternal(
p, std::is_convertible<T*, MessageLite*>());
}
static void InternalSwap(T* a, T* b) { a->InternalSwap(b); }
// Creates message-owned arena.
static Arena* CreateMessageOwnedArena() {
return new Arena(internal::MessageOwned{});
}
// Checks whether the given arena is message-owned.
static bool IsMessageOwnedArena(Arena* arena) {
return arena->IsMessageOwned();
}
private:
static Arena* GetArenaForAllocationInternal(
const T* p, std::true_type /*is_derived_from<MessageLite>*/) {
return p->GetArenaForAllocation();
@ -500,6 +498,29 @@ class PROTOBUF_EXPORT PROTOBUF_ALIGNAS(8) Arena final {
friend class TestUtil::ReflectionTester;
};
// Provides access to protected GetOwningArena to generated messages. For
// internal use only.
template <typename T>
static Arena* InternalGetOwningArena(const T* p) {
return InternalHelper<T>::GetOwningArena(p);
}
// Provides access to protected GetArenaForAllocation to generated messages.
// For internal use only.
template <typename T>
static Arena* InternalGetArenaForAllocation(const T* p) {
return InternalHelper<T>::GetArenaForAllocationInternal(
p, std::is_convertible<T*, MessageLite*>());
}
// Creates message-owned arena. For internal use only.
static Arena* InternalCreateMessageOwnedArena() {
return new Arena(internal::MessageOwned{});
}
// Checks whether this arena is message-owned. For internal use only.
bool InternalIsMessageOwnedArena() { return IsMessageOwned(); }
// Helper typetraits that indicates support for arenas in a type T at compile
// time. This is public only to allow construction of higher-level templated
// utilities.
@ -532,6 +553,10 @@ class PROTOBUF_EXPORT PROTOBUF_ALIGNAS(8) Arena final {
return impl_.IsMessageOwned();
}
void ReturnArrayMemory(void* p, size_t size) {
impl_.ReturnArrayMemory(p, size);
}
template <typename T, typename... Args>
PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena,
Args&&... args) {
@ -622,7 +647,7 @@ class PROTOBUF_EXPORT PROTOBUF_ALIGNAS(8) Arena final {
// 8 AlignUpTo can be elided.
const size_t n = sizeof(T) * num_elements;
return static_cast<T*>(
AllocateAlignedWithHook(n, alignof(T), RTTI_TYPE_ID(T)));
AllocateAlignedWithHookForArray(n, alignof(T), RTTI_TYPE_ID(T)));
}
template <typename T, typename... Args>
@ -765,17 +790,18 @@ class PROTOBUF_EXPORT PROTOBUF_ALIGNAS(8) Arena final {
return nullptr;
}
// For friends of arena.
void* AllocateAligned(size_t n, size_t align = 8) {
void* AllocateAlignedWithHookForArray(size_t n, size_t align,
const std::type_info* type) {
if (align <= 8) {
return AllocateAlignedNoHook(internal::AlignUpTo8(n));
return AllocateAlignedWithHookForArray(internal::AlignUpTo8(n), type);
} else {
// We are wasting space by over allocating align - 8 bytes. Compared
// to a dedicated function that takes current alignment in consideration.
// Such a scheme would only waste (align - 8)/2 bytes on average, but
// requires a dedicated function in the outline arena allocation
// functions. Possibly re-evaluate tradeoffs later.
return internal::AlignTo(AllocateAlignedNoHook(n + align - 8), align);
return internal::AlignTo(
AllocateAlignedWithHookForArray(n + align - 8, type), align);
}
}
@ -786,7 +812,7 @@ class PROTOBUF_EXPORT PROTOBUF_ALIGNAS(8) Arena final {
} else {
// We are wasting space by over allocating align - 8 bytes. Compared
// to a dedicated function that takes current alignment in consideration.
// Such a schemee would only waste (align - 8)/2 bytes on average, but
// Such a scheme would only waste (align - 8)/2 bytes on average, but
// requires a dedicated function in the outline arena allocation
// functions. Possibly re-evaluate tradeoffs later.
return internal::AlignTo(AllocateAlignedWithHook(n + align - 8, type),
@ -796,18 +822,22 @@ class PROTOBUF_EXPORT PROTOBUF_ALIGNAS(8) Arena final {
void* AllocateAlignedNoHook(size_t n);
void* AllocateAlignedWithHook(size_t n, const std::type_info* type);
void* AllocateAlignedWithHookForArray(size_t n, const std::type_info* type);
std::pair<void*, internal::SerialArena::CleanupNode*>
AllocateAlignedWithCleanup(size_t n, const std::type_info* type);
template <typename Type>
friend class internal::GenericTypeHandler;
friend struct internal::ArenaStringPtr; // For AllocateAligned.
friend class internal::InlinedStringField; // For AllocateAligned.
friend class internal::InternalMetadata; // For user_arena().
friend class internal::LazyField; // For CreateMaybeMessage.
friend class internal::EpsCopyInputStream; // For parser performance
friend class MessageLite;
template <typename Key, typename T>
friend class Map;
template <typename>
friend class RepeatedField; // For ReturnArrayMemory
friend class internal::RepeatedPtrFieldBase; // For ReturnArrayMemory
friend struct internal::ArenaTestPeer;
};
// Defined above for supporting environments without RTTI.

146
r5dev/thirdparty/protobuf/arena_impl.h vendored
View File

@ -39,11 +39,15 @@
#include <thirdparty/protobuf/stubs/common.h>
#include <thirdparty/protobuf/stubs/logging.h>
#include <thirdparty/protobuf/stubs/port.h>
#ifdef ADDRESS_SANITIZER
#include <sanitizer/asan_interface.h>
#endif // ADDRESS_SANITIZER
#include <thirdparty/protobuf/arenaz_sampler.h>
// Must be included last.
#include <thirdparty/protobuf/port_def.inc>
@ -51,6 +55,13 @@ namespace google {
namespace protobuf {
namespace internal {
// To prevent sharing cache lines between threads
#ifdef __cpp_aligned_new
enum { kCacheAlignment = 64 };
#else
enum { kCacheAlignment = alignof(max_align_t) }; // do the best we can
#endif
inline constexpr size_t AlignUpTo8(size_t n) {
// Align n to next multiple of 8 (from Hacker's Delight, Chapter 3.)
return (n + 7) & static_cast<size_t>(-8);
@ -177,6 +188,8 @@ class TaggedAllocationPolicyPtr {
uintptr_t policy_;
};
enum class AllocationClient { kDefault, kArray };
// A simple arena allocator. Calls to allocate functions must be properly
// serialized by the caller, hence this class cannot be used as a general
// purpose allocator in a multi-threaded program. It serves as a building block
@ -208,11 +221,47 @@ class PROTOBUF_EXPORT SerialArena {
}
uint64_t SpaceUsed() const;
bool HasSpace(size_t n) { return n <= static_cast<size_t>(limit_ - ptr_); }
bool HasSpace(size_t n) const {
return n <= static_cast<size_t>(limit_ - ptr_);
}
// See comments on `cached_blocks_` member for details.
PROTOBUF_ALWAYS_INLINE void* TryAllocateFromCachedBlock(size_t size) {
if (PROTOBUF_PREDICT_FALSE(size < 16)) return nullptr;
// We round up to the next larger block in case the memory doesn't match
// the pattern we are looking for.
const size_t index = Bits::Log2FloorNonZero64(size - 1) - 3;
if (index >= cached_block_length_) return nullptr;
auto& cached_head = cached_blocks_[index];
if (cached_head == nullptr) return nullptr;
void* ret = cached_head;
#ifdef ADDRESS_SANITIZER
ASAN_UNPOISON_MEMORY_REGION(ret, size);
#endif // ADDRESS_SANITIZER
cached_head = cached_head->next;
return ret;
}
// In kArray mode we look through cached blocks.
// We do not do this by default because most non-array allocations will not
// have the right size and will fail to find an appropriate cached block.
//
// TODO(sbenza): Evaluate if we should use cached blocks for message types of
// the right size. We can statically know if the allocation size can benefit
// from it.
template <AllocationClient alloc_client = AllocationClient::kDefault>
void* AllocateAligned(size_t n, const AllocationPolicy* policy) {
GOOGLE_DCHECK_EQ(internal::AlignUpTo8(n), n); // Must be already aligned.
GOOGLE_DCHECK_GE(limit_, ptr_);
if (alloc_client == AllocationClient::kArray) {
if (void* res = TryAllocateFromCachedBlock(n)) {
return res;
}
}
if (PROTOBUF_PREDICT_FALSE(!HasSpace(n))) {
return AllocateAlignedFallback(n, policy);
}
@ -229,6 +278,50 @@ class PROTOBUF_EXPORT SerialArena {
return ret;
}
// See comments on `cached_blocks_` member for details.
void ReturnArrayMemory(void* p, size_t size) {
// We only need to check for 32-bit platforms.
// In 64-bit platforms the minimum allocation size from Repeated*Field will
// be 16 guaranteed.
if (sizeof(void*) < 8) {
if (PROTOBUF_PREDICT_FALSE(size < 16)) return;
} else {
GOOGLE_DCHECK(size >= 16);
}
// We round down to the next smaller block in case the memory doesn't match
// the pattern we are looking for. eg, someone might have called Reserve()
// on the repeated field.
const size_t index = Bits::Log2FloorNonZero64(size) - 4;
if (PROTOBUF_PREDICT_FALSE(index >= cached_block_length_)) {
// We can't put this object on the freelist so make this object the
// freelist. It is guaranteed it is larger than the one we have, and
// large enough to hold another allocation of `size`.
CachedBlock** new_list = static_cast<CachedBlock**>(p);
size_t new_size = size / sizeof(CachedBlock*);
std::copy(cached_blocks_, cached_blocks_ + cached_block_length_,
new_list);
std::fill(new_list + cached_block_length_, new_list + new_size, nullptr);
cached_blocks_ = new_list;
// Make the size fit in uint8_t. This is the power of two, so we don't
// need anything larger.
cached_block_length_ =
static_cast<uint8_t>(std::min(size_t{64}, new_size));
return;
}
auto& cached_head = cached_blocks_[index];
auto* new_node = static_cast<CachedBlock*>(p);
new_node->next = cached_head;
cached_head = new_node;
#ifdef ADDRESS_SANITIZER
ASAN_POISON_MEMORY_REGION(p, size);
#endif // ADDRESS_SANITIZER
}
public:
// Allocate space if the current region provides enough space.
bool MaybeAllocateAligned(size_t n, void** out) {
@ -279,7 +372,8 @@ class PROTOBUF_EXPORT SerialArena {
// Creates a new SerialArena inside mem using the remaining memory as for
// future allocations.
static SerialArena* New(SerialArena::Memory mem, void* owner);
static SerialArena* New(SerialArena::Memory mem, void* owner,
ThreadSafeArenaStats* stats);
// Free SerialArena returning the memory passed in to New
template <typename Deallocator>
Memory Free(Deallocator deallocator);
@ -310,10 +404,28 @@ class PROTOBUF_EXPORT SerialArena {
// head_ (and head_->pos will always be non-canonical). We keep these
// here to reduce indirection.
char* ptr_;
// Limiting address up to which memory can be allocated from the head block.
char* limit_;
// For holding sampling information. The pointer is owned by the
// ThreadSafeArena that holds this serial arena.
ThreadSafeArenaStats* arena_stats_;
// Repeated*Field and Arena play together to reduce memory consumption by
// reusing blocks. Currently, natural growth of the repeated field types makes
// them allocate blocks of size `8 + 2^N, N>=3`.
// When the repeated field grows returns the previous block and we put it in
// this free list.
// `cached_blocks_[i]` points to the free list for blocks of size `8+2^(i+3)`.
// The array of freelists is grown when needed in `ReturnArrayMemory()`.
struct CachedBlock {
// Simple linked list.
CachedBlock* next;
};
uint8_t cached_block_length_ = 0;
CachedBlock** cached_blocks_ = nullptr;
// Constructor is private as only New() should be used.
inline SerialArena(Block* b, void* owner);
inline SerialArena(Block* b, void* owner, ThreadSafeArenaStats* stats);
void* AllocateAlignedFallback(size_t n, const AllocationPolicy* policy);
std::pair<void*, CleanupNode*> AllocateAlignedWithCleanupFallback(
size_t n, const AllocationPolicy* policy);
@ -368,26 +480,34 @@ class PROTOBUF_EXPORT ThreadSafeArena {
uint64_t SpaceAllocated() const;
uint64_t SpaceUsed() const;
template <AllocationClient alloc_client = AllocationClient::kDefault>
void* AllocateAligned(size_t n, const std::type_info* type) {
SerialArena* arena;
if (PROTOBUF_PREDICT_TRUE(!alloc_policy_.should_record_allocs() &&
GetSerialArenaFast(&arena))) {
return arena->AllocateAligned(n, AllocPolicy());
return arena->AllocateAligned<alloc_client>(n, AllocPolicy());
} else {
return AllocateAlignedFallback(n, type);
}
}
void ReturnArrayMemory(void* p, size_t size) {
SerialArena* arena;
if (PROTOBUF_PREDICT_TRUE(GetSerialArenaFast(&arena))) {
arena->ReturnArrayMemory(p, size);
}
}
// This function allocates n bytes if the common happy case is true and
// returns true. Otherwise does nothing and returns false. This strange
// semantics is necessary to allow callers to program functions that only
// have fallback function calls in tail position. This substantially improves
// code for the happy path.
PROTOBUF_NDEBUG_INLINE bool MaybeAllocateAligned(size_t n, void** out) {
SerialArena* a;
SerialArena* arena;
if (PROTOBUF_PREDICT_TRUE(!alloc_policy_.should_record_allocs() &&
GetSerialArenaFromThreadCache(&a))) {
return a->MaybeAllocateAligned(n, out);
GetSerialArenaFromThreadCache(&arena))) {
return arena->MaybeAllocateAligned(n, out);
}
return false;
}
@ -411,6 +531,8 @@ class PROTOBUF_EXPORT ThreadSafeArena {
TaggedAllocationPolicyPtr alloc_policy_; // Tagged pointer to AllocPolicy.
static_assert(std::is_trivially_destructible<SerialArena>{},
"SerialArena needs to be trivially destructible.");
// Pointer to a linked list of SerialArena.
std::atomic<SerialArena*> threads_;
std::atomic<SerialArena*> hint_; // Fast thread-local block access
@ -449,7 +571,7 @@ class PROTOBUF_EXPORT ThreadSafeArena {
// fast path optimizes the case where a single thread uses multiple arenas.
ThreadCache* tc = &thread_cache();
SerialArena* serial = hint_.load(std::memory_order_acquire);
if (PROTOBUF_PREDICT_TRUE(serial != NULL && serial->owner() == tc)) {
if (PROTOBUF_PREDICT_TRUE(serial != nullptr && serial->owner() == tc)) {
*arena = serial;
return true;
}
@ -487,7 +609,7 @@ class PROTOBUF_EXPORT ThreadSafeArena {
#ifdef _MSC_VER
#pragma warning(disable : 4324)
#endif
struct alignas(64) ThreadCache {
struct alignas(kCacheAlignment) ThreadCache {
#if defined(GOOGLE_PROTOBUF_NO_THREADLOCAL)
// If we are using the ThreadLocalStorage class to store the ThreadCache,
// then the ThreadCache's default constructor has to be responsible for
@ -495,7 +617,7 @@ class PROTOBUF_EXPORT ThreadSafeArena {
ThreadCache()
: next_lifecycle_id(0),
last_lifecycle_id_seen(-1),
last_serial_arena(NULL) {}
last_serial_arena(nullptr) {}
#endif
// Number of per-thread lifecycle IDs to reserve. Must be power of two.
@ -518,7 +640,7 @@ class PROTOBUF_EXPORT ThreadSafeArena {
#ifdef _MSC_VER
#pragma warning(disable : 4324)
#endif
struct alignas(64) CacheAlignedLifecycleIdGenerator {
struct alignas(kCacheAlignment) CacheAlignedLifecycleIdGenerator {
std::atomic<LifecycleIdAtomic> id;
};
static CacheAlignedLifecycleIdGenerator lifecycle_id_generator_;
@ -535,6 +657,8 @@ class PROTOBUF_EXPORT ThreadSafeArena {
static ThreadCache& thread_cache() { return thread_cache_; }
#endif
ThreadSafeArenaStatsHandle arena_stats_;
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ThreadSafeArena);
// All protos have pointers back to the arena hence Arena must have
// pointer stability.

1
r5dev/thirdparty/protobuf/arena_test_util.cc vendored
View File

@ -29,6 +29,7 @@
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <thirdparty/protobuf/arena_test_util.h>
#include <thirdparty/protobuf/stubs/logging.h>
#include <thirdparty/protobuf/stubs/common.h>

8
r5dev/thirdparty/protobuf/arena_test_util.h vendored
View File

@ -33,9 +33,9 @@
#include <thirdparty/protobuf/stubs/logging.h>
#include <thirdparty/protobuf/stubs/common.h>
#include <thirdparty/protobuf/arena.h>
#include <thirdparty/protobuf/io/coded_stream.h>
#include <thirdparty/protobuf/io/zero_copy_stream_impl_lite.h>
#include <thirdparty/protobuf/arena.h>
namespace google {
namespace protobuf {
@ -76,6 +76,12 @@ void TestParseCorruptedString(const T& message) {
namespace internal {
struct ArenaTestPeer {
static void ReturnArrayMemory(Arena* arena, void* p, size_t size) {
arena->ReturnArrayMemory(p, size);
}
};
class NoHeapChecker {
public:
NoHeapChecker() { capture_alloc.Hook(); }

89
r5dev/thirdparty/protobuf/arena_unittest.cc vendored
View File

@ -41,27 +41,29 @@
#include <thirdparty/protobuf/stubs/logging.h>
#include <thirdparty/protobuf/stubs/common.h>
#include <thirdparty/protobuf/arena_test_util.h>
#include <thirdparty/protobuf/test_util.h>
#include <thirdparty/protobuf/unittest.pb.h>
#include <thirdparty/protobuf/unittest_arena.pb.h>
#include <thirdparty/protobuf/io/coded_stream.h>
#include <thirdparty/protobuf/io/zero_copy_stream_impl_lite.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <thirdparty/protobuf/stubs/strutil.h>
#include <thirdparty/protobuf/arena_test_util.h>
#include <thirdparty/protobuf/descriptor.h>
#include <thirdparty/protobuf/extension_set.h>
#include <thirdparty/protobuf/io/coded_stream.h>
#include <thirdparty/protobuf/io/zero_copy_stream_impl_lite.h>
#include <thirdparty/protobuf/message.h>
#include <thirdparty/protobuf/message_lite.h>
#include <thirdparty/protobuf/repeated_field.h>
#include <thirdparty/protobuf/test_util.h>
#include <thirdparty/protobuf/unknown_field_set.h>
#include <thirdparty/protobuf/wire_format_lite.h>
#include <gtest/gtest.h>
#include <thirdparty/protobuf/stubs/strutil.h>
// Must be included last
#include <thirdparty/protobuf/port_def.inc>
using proto2_arena_unittest::ArenaMessage;
using protobuf_unittest::ForeignMessage;
using protobuf_unittest::TestAllExtensions;
using protobuf_unittest::TestAllTypes;
using protobuf_unittest::TestEmptyMessage;
@ -542,6 +544,16 @@ TEST(ArenaTest, UnsafeArenaSwap) {
TestUtil::ExpectAllFieldsSet(*message2);
}
TEST(ArenaTest, GetOwningArena) {
Arena arena;
auto* m1 = Arena::CreateMessage<TestAllTypes>(&arena);
EXPECT_EQ(Arena::InternalGetOwningArena(m1), &arena);
EXPECT_EQ(&arena, Arena::InternalGetOwningArena(
m1->mutable_repeated_foreign_message()));
EXPECT_EQ(&arena,
Arena::InternalGetOwningArena(m1->mutable_repeated_int32()));
}
TEST(ArenaTest, SwapBetweenArenasUsingReflection) {
Arena arena1;
TestAllTypes* arena1_message = Arena::CreateMessage<TestAllTypes>(&arena1);
@ -1465,6 +1477,71 @@ TEST(ArenaTest, AddCleanup) {
}
}
TEST(ArenaTest, SpaceReuseForArraysSizeChecks) {
// Limit to 1<<20 to avoid using too much memory on the test.
for (int i = 0; i < 20; ++i) {
SCOPED_TRACE(i);
Arena arena;
std::vector<void*> pointers;
const size_t size = 16 << i;
for (int j = 0; j < 10; ++j) {
pointers.push_back(Arena::CreateArray<char>(&arena, size));
}
for (void* p : pointers) {
internal::ArenaTestPeer::ReturnArrayMemory(&arena, p, size);
}
std::vector<void*> second_pointers;
for (int j = 9; j != 0; --j) {
second_pointers.push_back(Arena::CreateArray<char>(&arena, size));
}
// The arena will give us back the pointers we returned, except the first
// one. That one becomes part of the freelist data structure.
ASSERT_THAT(second_pointers,
testing::UnorderedElementsAreArray(
std::vector<void*>(pointers.begin() + 1, pointers.end())));
}
}
TEST(ArenaTest, SpaceReusePoisonsAndUnpoisonsMemory) {
#ifdef ADDRESS_SANITIZER
char buf[1024]{};
{
Arena arena(buf, sizeof(buf));
std::vector<void*> pointers;
for (int i = 0; i < 100; ++i) {
pointers.push_back(Arena::CreateArray<char>(&arena, 16));
}
for (void* p : pointers) {
internal::ArenaTestPeer::ReturnArrayMemory(&arena, p, 16);
// The first one is not poisoned because it becomes the freelist.
if (p != pointers[0]) EXPECT_TRUE(__asan_address_is_poisoned(p));
}
bool found_poison = false;
for (char& c : buf) {
if (__asan_address_is_poisoned(&c)) {
found_poison = true;
break;
}
}
EXPECT_TRUE(found_poison);
}
// Should not be poisoned after destruction.
for (char& c : buf) {
ASSERT_FALSE(__asan_address_is_poisoned(&c));
}
#else // ADDRESS_SANITIZER
GTEST_SKIP();
#endif // ADDRESS_SANITIZER
}
namespace {
uint32_t hooks_num_init = 0;
uint32_t hooks_num_allocations = 0;

253
r5dev/thirdparty/protobuf/arenastring.cc vendored
View File

@ -30,13 +30,14 @@
#include <thirdparty/protobuf/arenastring.h>
#include <cstddef>
#include <thirdparty/protobuf/stubs/logging.h>
#include <thirdparty/protobuf/stubs/common.h>
#include <thirdparty/protobuf/parse_context.h>
#include <thirdparty/protobuf/io/coded_stream.h>
#include <thirdparty/protobuf/message_lite.h>
#include <thirdparty/protobuf/stubs/mutex.h>
#include <thirdparty/protobuf/stubs/strutil.h>
#include <thirdparty/protobuf/message_lite.h>
#include <thirdparty/protobuf/parse_context.h>
#include <thirdparty/protobuf/stubs/stl_util.h>
// clang-format off
@ -47,6 +48,28 @@ namespace google {
namespace protobuf {
namespace internal {
namespace {
// TaggedStringPtr::Flags uses the lower 2 bits as tags.
// Enforce that allocated data aligns to at least 4 bytes, and that
// the alignment of the global const string value does as well.
// The alignment guaranteed by `new std::string` depends on both:
// - new align = __STDCPP_DEFAULT_NEW_ALIGNMENT__ / max_align_t
// - alignof(std::string)
#ifdef __STDCPP_DEFAULT_NEW_ALIGNMENT__
constexpr size_t kNewAlign = __STDCPP_DEFAULT_NEW_ALIGNMENT__;
#elif (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40900
constexpr size_t kNewAlign = alignof(::max_align_t);
#else
constexpr size_t kNewAlign = alignof(std::max_align_t);
#endif
constexpr size_t kStringAlign = alignof(std::string);
static_assert((kStringAlign > kNewAlign ? kStringAlign : kNewAlign) >= 4, "");
static_assert(alignof(ExplicitlyConstructedArenaString) >= 4, "");
} // namespace
const std::string& LazyString::Init() const {
static WrappedMutex mu{GOOGLE_PROTOBUF_LINKER_INITIALIZED};
mu.Lock();
@ -61,185 +84,150 @@ const std::string& LazyString::Init() const {
return *res;
}
namespace {
std::string* ArenaStringPtr::SetAndReturnNewString() {
std::string* new_string = new std::string();
tagged_ptr_.Set(new_string);
return new_string;
#if defined(NDEBUG) || !GOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL
class ScopedCheckPtrInvariants {
public:
explicit ScopedCheckPtrInvariants(const TaggedStringPtr*) {}
};
#endif // NDEBUG || !GOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL
// Creates a heap allocated std::string value.
inline TaggedStringPtr CreateString(ConstStringParam value) {
TaggedStringPtr res;
res.SetAllocated(new std::string(value.data(), value.length()));
return res;
}
void ArenaStringPtr::DestroyNoArenaSlowPath() { delete UnsafeMutablePointer(); }
#if !GOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL
void ArenaStringPtr::Set(const std::string* default_value,
ConstStringParam value, ::google::protobuf::Arena* arena) {
if (IsDefault(default_value)) {
tagged_ptr_.Set(Arena::Create<std::string>(arena, value));
// Creates an arena allocated std::string value.
TaggedStringPtr CreateArenaString(Arena& arena, ConstStringParam s) {
TaggedStringPtr res;
res.SetMutableArena(Arena::Create<std::string>(&arena, s.data(), s.length()));
return res;
}
#endif // !GOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL
} // namespace
void ArenaStringPtr::Set(ConstStringParam value, Arena* arena) {
ScopedCheckPtrInvariants check(&tagged_ptr_);
if (IsDefault()) {
// If we're not on an arena, skip straight to a true string to avoid
// possible copy cost later.
tagged_ptr_ = arena != nullptr ? CreateArenaString(*arena, value)
: CreateString(value);
} else {
UnsafeMutablePointer()->assign(value.data(), value.length());
}
}
void ArenaStringPtr::Set(const std::string* default_value, std::string&& value,
::google::protobuf::Arena* arena) {
if (IsDefault(default_value)) {
if (arena == nullptr) {
tagged_ptr_.Set(new std::string(std::move(value)));
} else {
tagged_ptr_.Set(Arena::Create<std::string>(arena, std::move(value)));
}
} else if (IsDonatedString()) {
void ArenaStringPtr::Set(std::string&& value, Arena* arena) {
ScopedCheckPtrInvariants check(&tagged_ptr_);
if (IsDefault()) {
NewString(arena, std::move(value));
} else if (IsFixedSizeArena()) {
std::string* current = tagged_ptr_.Get();
auto* s = new (current) std::string(std::move(value));
arena->OwnDestructor(s);
tagged_ptr_.Set(s);
} else /* !IsDonatedString() */ {
tagged_ptr_.SetMutableArena(s);
} else /* !IsFixedSizeArena() */ {
*UnsafeMutablePointer() = std::move(value);
}
}
void ArenaStringPtr::Set(EmptyDefault, ConstStringParam value,
::google::protobuf::Arena* arena) {
Set(&GetEmptyStringAlreadyInited(), value, arena);
}
void ArenaStringPtr::Set(EmptyDefault, std::string&& value,
::google::protobuf::Arena* arena) {
Set(&GetEmptyStringAlreadyInited(), std::move(value), arena);
}
void ArenaStringPtr::Set(NonEmptyDefault, ConstStringParam value,
::google::protobuf::Arena* arena) {
Set(nullptr, value, arena);
}
void ArenaStringPtr::Set(NonEmptyDefault, std::string&& value,
::google::protobuf::Arena* arena) {
Set(nullptr, std::move(value), arena);
}
std::string* ArenaStringPtr::Mutable(EmptyDefault, ::google::protobuf::Arena* arena) {
if (!IsDonatedString() && !IsDefault(&GetEmptyStringAlreadyInited())) {
return UnsafeMutablePointer();
std::string* ArenaStringPtr::Mutable(Arena* arena) {
ScopedCheckPtrInvariants check(&tagged_ptr_);
if (tagged_ptr_.IsMutable()) {
return tagged_ptr_.Get();
} else {
return MutableSlow(arena);
}
}
std::string* ArenaStringPtr::Mutable(const LazyString& default_value,
::google::protobuf::Arena* arena) {
if (!IsDonatedString() && !IsDefault(nullptr)) {
return UnsafeMutablePointer();
Arena* arena) {
ScopedCheckPtrInvariants check(&tagged_ptr_);
if (tagged_ptr_.IsMutable()) {
return tagged_ptr_.Get();
} else {
return MutableSlow(arena, default_value);
}
}
std::string* ArenaStringPtr::MutableNoCopy(const std::string* default_value,
::google::protobuf::Arena* arena) {
if (!IsDonatedString() && !IsDefault(default_value)) {
return UnsafeMutablePointer();
std::string* ArenaStringPtr::MutableNoCopy(Arena* arena) {
ScopedCheckPtrInvariants check(&tagged_ptr_);
if (tagged_ptr_.IsMutable()) {
return tagged_ptr_.Get();
} else {
GOOGLE_DCHECK(IsDefault(default_value));
GOOGLE_DCHECK(IsDefault());
// Allocate empty. The contents are not relevant.
std::string* new_string = Arena::Create<std::string>(arena);
tagged_ptr_.Set(new_string);
return new_string;
return NewString(arena);
}
}
template <typename... Lazy>
std::string* ArenaStringPtr::MutableSlow(::google::protobuf::Arena* arena,
const Lazy&... lazy_default) {
const std::string* const default_value =
sizeof...(Lazy) == 0 ? &GetEmptyStringAlreadyInited() : nullptr;
GOOGLE_DCHECK(IsDefault(default_value));
std::string* new_string =
Arena::Create<std::string>(arena, lazy_default.get()...);
tagged_ptr_.Set(new_string);
return new_string;
GOOGLE_DCHECK(IsDefault());
// For empty defaults, this ends up calling the default constructor which is
// more efficient than a copy construction from
// GetEmptyStringAlreadyInited().
return NewString(arena, lazy_default.get()...);
}
std::string* ArenaStringPtr::Release(const std::string* default_value,
::google::protobuf::Arena* arena) {
if (IsDefault(default_value)) {
return nullptr;
} else {
return ReleaseNonDefault(default_value, arena);
std::string* ArenaStringPtr::Release() {
ScopedCheckPtrInvariants check(&tagged_ptr_);
if (IsDefault()) return nullptr;
std::string* released = tagged_ptr_.Get();
if (tagged_ptr_.IsArena()) {
released = tagged_ptr_.IsMutable() ? new std::string(std::move(*released))
: new std::string(*released);
}
InitDefault();
return released;
}
std::string* ArenaStringPtr::ReleaseNonDefault(const std::string* default_value,
::google::protobuf::Arena* arena) {
GOOGLE_DCHECK(!IsDefault(default_value));
if (!IsDonatedString()) {
std::string* released;
if (arena != nullptr) {
released = new std::string;
released->swap(*UnsafeMutablePointer());
} else {
released = UnsafeMutablePointer();
}
tagged_ptr_.Set(const_cast<std::string*>(default_value));
return released;
} else /* IsDonatedString() */ {
GOOGLE_DCHECK(arena != nullptr);
std::string* released = new std::string(Get());
tagged_ptr_.Set(const_cast<std::string*>(default_value));
return released;
}
}
void ArenaStringPtr::SetAllocated(const std::string* default_value,
std::string* value, ::google::protobuf::Arena* arena) {
void ArenaStringPtr::SetAllocated(std::string* value, Arena* arena) {
ScopedCheckPtrInvariants check(&tagged_ptr_);
// Release what we have first.
if (arena == nullptr && !IsDefault(default_value)) {
delete UnsafeMutablePointer();
}
Destroy();
if (value == nullptr) {
tagged_ptr_.Set(const_cast<std::string*>(default_value));
InitDefault();
} else {
#ifdef NDEBUG
tagged_ptr_.Set(value);
if (arena != nullptr) {
arena->Own(value);
}
#else
#ifndef NDEBUG
// On debug builds, copy the string so the address differs. delete will
// fail if value was a stack-allocated temporary/etc., which would have
// failed when arena ran its cleanup list.
std::string* new_value = Arena::Create<std::string>(arena, *value);
std::string* new_value = new std::string(std::move(*value));
delete value;
tagged_ptr_.Set(new_value);
#endif
value = new_value;
#endif // !NDEBUG
InitAllocated(value, arena);
}
}
void ArenaStringPtr::Destroy(const std::string* default_value,
::google::protobuf::Arena* arena) {
if (arena == nullptr) {
GOOGLE_DCHECK(!IsDonatedString());
if (!IsDefault(default_value)) {
delete UnsafeMutablePointer();
}
}
}
void ArenaStringPtr::Destroy(EmptyDefault, ::google::protobuf::Arena* arena) {
Destroy(&GetEmptyStringAlreadyInited(), arena);
}
void ArenaStringPtr::Destroy(NonEmptyDefault, ::google::protobuf::Arena* arena) {
Destroy(nullptr, arena);
void ArenaStringPtr::Destroy() {
delete tagged_ptr_.GetIfAllocated();
}
void ArenaStringPtr::ClearToEmpty() {
if (IsDefault(&GetEmptyStringAlreadyInited())) {
ScopedCheckPtrInvariants check(&tagged_ptr_);
if (IsDefault()) {
// Already set to default -- do nothing.
} else {
// Unconditionally mask away the tag.
//
// UpdateDonatedString uses assign when capacity is larger than the new
// UpdateArenaString uses assign when capacity is larger than the new
// value, which is trivially true in the donated string case.
// const_cast<std::string*>(PtrValue<std::string>())->clear();
tagged_ptr_.Get()->clear();
@ -248,34 +236,27 @@ void ArenaStringPtr::ClearToEmpty() {
void ArenaStringPtr::ClearToDefault(const LazyString& default_value,
::google::protobuf::Arena* arena) {
ScopedCheckPtrInvariants check(&tagged_ptr_);
(void)arena;
if (IsDefault(nullptr)) {
if (IsDefault()) {
// Already set to default -- do nothing.
} else if (!IsDonatedString()) {
} else {
UnsafeMutablePointer()->assign(default_value.get());
}
}
inline void SetStrWithHeapBuffer(std::string* str, ArenaStringPtr* s) {
TaggedPtr<std::string> res;
res.Set(str);
s->UnsafeSetTaggedPointer(res);
}
const char* EpsCopyInputStream::ReadArenaString(const char* ptr,
ArenaStringPtr* s,
Arena* arena) {
ScopedCheckPtrInvariants check(&s->tagged_ptr_);
GOOGLE_DCHECK(arena != nullptr);
int size = ReadSize(&ptr);
if (!ptr) return nullptr;
auto* str = Arena::Create<std::string>(arena);
auto* str = s->NewString(arena);
ptr = ReadString(ptr, size, str);
GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
SetStrWithHeapBuffer(str, s);
return ptr;
}

474
r5dev/thirdparty/protobuf/arenastring.h vendored
View File

@ -31,6 +31,7 @@
#ifndef GOOGLE_PROTOBUF_ARENASTRING_H__
#define GOOGLE_PROTOBUF_ARENASTRING_H__
#include <algorithm>
#include <string>
#include <type_traits>
#include <utility>
@ -39,7 +40,9 @@
#include <thirdparty/protobuf/stubs/common.h>
#include <thirdparty/protobuf/arena.h>
#include <thirdparty/protobuf/port.h>
#include <thirdparty/protobuf/explicitly_constructed.h>
// must be last:
#include <thirdparty/protobuf/port_def.inc>
#ifdef SWIG
@ -50,12 +53,14 @@
namespace google {
namespace protobuf {
namespace internal {
template <typename T>
class ExplicitlyConstructed;
class EpsCopyInputStream;
class SwapFieldHelper;
// Declared in message_lite.h
PROTOBUF_EXPORT extern ExplicitlyConstructedArenaString
fixed_address_empty_string;
// Lazy string instance to support string fields with non-empty default.
// These are initialized on the first call to .get().
class PROTOBUF_EXPORT LazyString {
@ -89,182 +94,229 @@ class PROTOBUF_EXPORT LazyString {
const std::string& Init() const;
};
template <typename T>
class TaggedPtr {
class TaggedStringPtr {
public:
TaggedPtr() = default;
explicit constexpr TaggedPtr(const ExplicitlyConstructed<std::string>* ptr)
: ptr_(const_cast<ExplicitlyConstructed<std::string>*>(ptr)) {}
// Bit flags qualifying string properties. We can use 2 bits as
// ptr_ is guaranteed and enforced to be aligned on 4 byte boundaries.
enum Flags {
kArenaBit = 0x1, // ptr is arena allocated
kMutableBit = 0x2, // ptr contents are fully mutable
kMask = 0x3 // Bit mask
};
void SetTagged(T* p) {
Set(p);
ptr_ = reinterpret_cast<void*>(as_int() | 1);
// Composed logical types
enum Type {
// Default strings are immutable and never owned.
kDefault = 0,
// Allocated strings are mutable and (as the name implies) owned.
// A heap allocated string must be deleted.
kAllocated = kMutableBit,
// Mutable arena strings are strings where the string instance is owned
// by the arena, but the string contents itself are owned by the string
// instance. Mutable arena string instances need to be destroyed which is
// typically done through a cleanup action added to the arena owning it.
kMutableArena = kArenaBit | kMutableBit,
// Fixed size arena strings are strings where both the string instance and
// the string contents are fully owned by the arena. Fixed size arena
// strings are a platform and c++ library specific customization. Fixed
// size arena strings are immutable, with the exception of custom internal
// updates to the content that fit inside the existing capacity.
// Fixed size arena strings must never be deleted or destroyed.
kFixedSizeArena = kArenaBit,
};
TaggedStringPtr() = default;
explicit constexpr TaggedStringPtr(ExplicitlyConstructedArenaString* ptr)
: ptr_(ptr) {}
// Sets the value to `p`, tagging the value as being a 'default' value.
// See documentation for kDefault for more info.
inline const std::string* SetDefault(const std::string* p) {
return TagAs(kDefault, const_cast<std::string*>(p));
}
void Set(T* p) { ptr_ = p; }
T* Get() const { return reinterpret_cast<T*>(as_int() & -2); }
bool IsTagged() const { return as_int() & 1; }
// Returned value is only safe to dereference if IsTagged() == false.
// It is safe to compare.
T* UnsafeGet() const { return static_cast<T*>(ptr_); }
// Sets the value to `p`, tagging the value as a heap allocated value.
// Allocated strings are mutable and (as the name implies) owned.
// `p` must not be null
inline std::string* SetAllocated(std::string* p) {
return TagAs(kAllocated, p);
}
bool IsNull() { return ptr_ == nullptr; }
// Sets the value to `p`, tagging the value as a fixed size arena string.
// See documentation for kFixedSizeArena for more info.
// `p` must not be null
inline std::string* SetFixedSizeArena(std::string* p) {
return TagAs(kFixedSizeArena, p);
}
// Sets the value to `p`, tagging the value as a mutable arena string.
// See documentation for kMutableArena for more info.
// `p` must not be null
inline std::string* SetMutableArena(std::string* p) {
return TagAs(kMutableArena, p);
}
// Returns true if the contents of the current string are fully mutable.
inline bool IsMutable() const { return as_int() & kMutableBit; }
// Returns true if the current string is an immutable default value.
inline bool IsDefault() const { return (as_int() & kMask) == kDefault; }
// If the current string is a heap-allocated mutable value, returns a pointer
// to it. Returns nullptr otherwise.
inline std::string *GetIfAllocated() const {
auto allocated = as_int() ^ kAllocated;
if (allocated & kMask) return nullptr;
auto ptr = reinterpret_cast<std::string*>(allocated);
PROTOBUF_ASSUME(ptr != nullptr);
return ptr;
}
// Returns true if the current string is an arena allocated value.
// This means it's either a mutable or fixed size arena string.
inline bool IsArena() const { return as_int() & kArenaBit; }
// Returns true if the current string is a fixed size arena allocated value.
inline bool IsFixedSizeArena() const {
return (as_int() & kMask) == kFixedSizeArena;
}
// Returns the contained string pointer.
inline std::string* Get() const {
return reinterpret_cast<std::string*>(as_int() & ~kMask);
}
// Returns true if the contained pointer is null, indicating some error.
// The Null value is only used during parsing for temporary values.
// A persisted ArenaStringPtr value is never null.
inline bool IsNull() { return ptr_ == nullptr; }
private:
static inline void assert_aligned(const void* p) {
GOOGLE_DCHECK_EQ(reinterpret_cast<uintptr_t>(p) & kMask, 0UL);
}
inline std::string* TagAs(Type type, std::string* p) {
GOOGLE_DCHECK(p != nullptr);
assert_aligned(p);
ptr_ = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(p) | type);
return p;
}
uintptr_t as_int() const { return reinterpret_cast<uintptr_t>(ptr_); }
void* ptr_;
};
static_assert(std::is_trivial<TaggedPtr<std::string>>::value,
"TaggedPtr must be trivial");
static_assert(std::is_trivial<TaggedStringPtr>::value,
"TaggedStringPtr must be trivial");
// This class encapsulates a pointer to a std::string with or without a donated
// buffer, tagged by bottom bit. It is a high-level wrapper that almost directly
// corresponds to the interface required by string fields in generated
// code. It replaces the old std::string* pointer in such cases.
// This class encapsulates a pointer to a std::string with or without arena
// owned contents, tagged by the bottom bits of the string pointer. It is a
// high-level wrapper that almost directly corresponds to the interface required
// by string fields in generated code. It replaces the old std::string* pointer
// in such cases.
//
// The object has different but similar code paths for when the default value is
// the empty string and when it is a non-empty string.
// The empty string is handled different throughout the library and there is a
// single global instance of it we can share.
// The string pointer is tagged to be either a default, externally owned value,
// a mutable heap allocated value, or an arena allocated value. The object uses
// a single global instance of an empty string that is used as the initial
// default value. Fields that have empty default values directly use this global
// default. Fields that have non empty default values are supported through
// lazily initialized default values managed by the LazyString class.
//
// For fields with an empty string default value, there are three distinct
// states:
//
// - Pointer set to 'String' tag (LSB is 0), equal to
// &GetEmptyStringAlreadyInited(): field is set to its default value. Points
// to a true std::string*, but we do not own that std::string* (it's a
// globally shared instance).
//
// - Pointer set to 'String' tag (LSB is 0), but not equal to the global empty
// string: field points to a true std::string* instance that we own. This
// instance is either on the heap or on the arena (i.e. registered on
// free()/destructor-call list) as appropriate.
//
// - Pointer set to 'DonatedString' tag (LSB is 1): points to a std::string
// instance with a buffer on the arena (arena is never nullptr in this case).
//
// For fields with a non-empty string default value, there are three distinct
// states:
//
// - Pointer set to 'String' tag (LSB is 0), equal to `nullptr`:
// Field is in "default" mode and does not point to any actual instance.
// Methods that might need to create an instance of the object will pass a
// `const LazyString&` for it.
//
// - Pointer set to 'String' tag (LSB is 0), but not equal to `nullptr`:
// field points to a true std::string* instance that we own. This instance is
// either on the heap or on the arena (i.e. registered on
// free()/destructor-call list) as appropriate.
//
// - Pointer set to 'DonatedString' tag (LSB is 1): points to a std::string
// instance with a buffer on the arena (arena is never nullptr in this case).
//
// Generated code and reflection code both ensure that ptr_ is never null for
// fields with an empty default.
// Generated code and reflection code both ensure that ptr_ is never null.
// Because ArenaStringPtr is used in oneof unions, its constructor is a NOP and
// so the field is always manually initialized via method calls.
// the field is always manually initialized via method calls.
//
// Side-note: why pass information about the default on every API call? Because
// we don't want to hold it in a member variable, or else this would go into
// every proto message instance. This would be a huge waste of space, since the
// default instance pointer is typically a global (static class field). We want
// the generated code to be as efficient as possible, and if we take
// the default value information as a parameter that's in practice taken from a
// static class field, and compare ptr_ to the default value, we end up with a
// single "cmp %reg, GLOBAL" in the resulting machine code. (Note that this also
// requires the String tag to be 0 so we can avoid the mask before comparing.)
// See TaggedStringPtr for more information about the types of string values
// being held, and the mutable and ownership invariants for each type.
struct PROTOBUF_EXPORT ArenaStringPtr {
ArenaStringPtr() = default;
explicit constexpr ArenaStringPtr(
const ExplicitlyConstructed<std::string>* default_value)
constexpr ArenaStringPtr(ExplicitlyConstructedArenaString* default_value,
ConstantInitialized)
: tagged_ptr_(default_value) {}
// Some methods below are overloaded on a `default_value` and on tags.
// The tagged overloads help reduce code size in the callers in generated
// code, while the `default_value` overloads are useful from reflection.
// By-value empty struct arguments are elided in the ABI.
struct EmptyDefault {};
struct NonEmptyDefault {};
// Called from generated code / reflection runtime only. Resets value to point
// to a default string pointer, with the semantics that this ArenaStringPtr
// does not own the pointed-to memory. Disregards initial value of ptr_ (so
// this is the *ONLY* safe method to call after construction or when
// reinitializing after becoming the active field in a oneof union).
inline void InitDefault();
void Set(const std::string* default_value, ConstStringParam value,
::google::protobuf::Arena* arena);
void Set(const std::string* default_value, std::string&& value,
::google::protobuf::Arena* arena);
void Set(EmptyDefault, ConstStringParam value, ::google::protobuf::Arena* arena);
void Set(EmptyDefault, std::string&& value, ::google::protobuf::Arena* arena);
void Set(NonEmptyDefault, ConstStringParam value, ::google::protobuf::Arena* arena);
void Set(NonEmptyDefault, std::string&& value, ::google::protobuf::Arena* arena);
template <typename FirstParam>
void Set(FirstParam p1, const char* str, ::google::protobuf::Arena* arena) {
Set(p1, ConstStringParam(str), arena);
}
template <typename FirstParam>
void Set(FirstParam p1, const char* str, size_t size,
// Similar to `InitDefault` except that it allows the default value to be
// initialized to an externally owned string. This method is called from
// parsing code. `str` must not be null and outlive this instance.
inline void InitExternal(const std::string* str);
// Called from generated code / reflection runtime only. Resets the value of
// this instances to the heap allocated value in `str`. `str` must not be
// null. Invokes `arena->Own(str)` to transfer ownership into the arena if
// `arena` is not null, else, `str` will be owned by ArenaStringPtr. This
// function should only be used to initialize a ArenaStringPtr or on an
// instance known to not carry any heap allocated value.
inline void InitAllocated(std::string* str, Arena* arena);
void Set(ConstStringParam value, Arena* arena);
void Set(std::string&& value, Arena* arena);
void Set(const char* s, Arena* arena);
void Set(const char* s, size_t n, Arena* arena);
void SetBytes(ConstStringParam value, Arena* arena);
void SetBytes(std::string&& value, Arena* arena);
void SetBytes(const char* s, Arena* arena);
void SetBytes(const void* p, size_t n, Arena* arena);
template <typename RefWrappedType>
void Set(std::reference_wrapper<RefWrappedType> const_string_ref,
::google::protobuf::Arena* arena) {
ConstStringParam sp{str, size}; // for string_view and `const string &`
Set(p1, sp, arena);
}
template <typename FirstParam, typename RefWrappedType>
void Set(FirstParam p1,
std::reference_wrapper<RefWrappedType> const_string_ref,
::google::protobuf::Arena* arena) {
Set(p1, const_string_ref.get(), arena);
Set(const_string_ref.get(), arena);
}
template <typename FirstParam, typename SecondParam>
void SetBytes(FirstParam p1, SecondParam&& p2, ::google::protobuf::Arena* arena) {
Set(p1, static_cast<SecondParam&&>(p2), arena);
}
template <typename FirstParam>
void SetBytes(FirstParam p1, const void* str, size_t size,
::google::protobuf::Arena* arena) {
// must work whether ConstStringParam is string_view or `const string &`
ConstStringParam sp{static_cast<const char*>(str), size};
Set(p1, sp, arena);
}
// Returns a mutable std::string reference.
// The version accepting a `LazyString` value is used in the generated code to
// initialize mutable copies for fields with a non-empty default where the
// default value is lazily initialized.
std::string* Mutable(Arena* arena);
std::string* Mutable(const LazyString& default_value, Arena* arena);
// Gets a mutable pointer with unspecified contents.
// This function is identical to Mutable(), except it is optimized for the
// case where the caller is not interested in the current contents. For
// example, if the current field is not mutable, it will re-initialize the
// value with an empty string rather than a (non-empty) default value.
// Likewise, if the current value is a fixed size arena string with contents,
// it will be initialized into an empty mutable arena string.
std::string* MutableNoCopy(Arena* arena);
// Basic accessors.
PROTOBUF_NDEBUG_INLINE const std::string& Get() const {
// Unconditionally mask away the tag.
return *tagged_ptr_.Get();
}
PROTOBUF_NDEBUG_INLINE const std::string* GetPointer() const {
// Unconditionally mask away the tag.
// Returns a pointer to the stored contents for this instance.
// This method is for internal debugging and tracking purposes only.
PROTOBUF_NDEBUG_INLINE const std::string* UnsafeGetPointer() const
PROTOBUF_RETURNS_NONNULL {
return tagged_ptr_.Get();
}
// For fields with an empty default value.
std::string* Mutable(EmptyDefault, ::google::protobuf::Arena* arena);
// For fields with a non-empty default value.
std::string* Mutable(const LazyString& default_value, ::google::protobuf::Arena* arena);
// Release returns a std::string* instance that is heap-allocated and is not
// Own()'d by any arena. If the field is not set, this returns nullptr. The
// caller retains ownership. Clears this field back to nullptr state. Used to
// implement release_<field>() methods on generated classes.
PROTOBUF_NODISCARD std::string* Release(const std::string* default_value,
::google::protobuf::Arena* arena);
PROTOBUF_NODISCARD std::string* ReleaseNonDefault(
const std::string* default_value, ::google::protobuf::Arena* arena);
// caller retains ownership. Clears this field back to the default state.
// Used to implement release_<field>() methods on generated classes.
PROTOBUF_NODISCARD std::string* Release();
// Takes a std::string that is heap-allocated, and takes ownership. The
// std::string's destructor is registered with the arena. Used to implement
// set_allocated_<field> in generated classes.
void SetAllocated(const std::string* default_value, std::string* value,
::google::protobuf::Arena* arena);
// Swaps internal pointers. Arena-safety semantics: this is guarded by the
// logic in Swap()/UnsafeArenaSwap() at the message level, so this method is
// 'unsafe' if called directly.
inline PROTOBUF_NDEBUG_INLINE static void InternalSwap(
const std::string* default_value, ArenaStringPtr* rhs, Arena* rhs_arena,
ArenaStringPtr* lhs, Arena* lhs_arena);
void SetAllocated(std::string* value, Arena* arena);
// Frees storage (if not on an arena).
void Destroy(const std::string* default_value, ::google::protobuf::Arena* arena);
void Destroy(EmptyDefault, ::google::protobuf::Arena* arena);
void Destroy(NonEmptyDefault, ::google::protobuf::Arena* arena);
void Destroy();
// Clears content, but keeps allocated std::string, to avoid the overhead of
// heap operations. After this returns, the content (as seen by the user) will
@ -281,48 +333,40 @@ struct PROTOBUF_EXPORT ArenaStringPtr {
// (as seen by the user) will always be equal to |default_value|.
void ClearToDefault(const LazyString& default_value, ::google::protobuf::Arena* arena);
// Called from generated code / reflection runtime only. Resets value to point
// to a default string pointer, with the semantics that this
// ArenaStringPtr does not own the pointed-to memory. Disregards initial value
// of ptr_ (so this is the *ONLY* safe method to call after construction or
// when reinitializing after becoming the active field in a oneof union).
inline void UnsafeSetDefault(const std::string* default_value);
// Returns a mutable pointer, but doesn't initialize the string to the
// default value.
std::string* MutableNoArenaNoDefault(const std::string* default_value);
// Get a mutable pointer with unspecified contents.
// Similar to `MutableNoArenaNoDefault`, but also handles the arena case.
// If the value was donated, the contents are discarded.
std::string* MutableNoCopy(const std::string* default_value,
::google::protobuf::Arena* arena);
// Destroy the string. Assumes `arena == nullptr`.
void DestroyNoArena(const std::string* default_value);
// Swaps internal pointers. Arena-safety semantics: this is guarded by the
// logic in Swap()/UnsafeArenaSwap() at the message level, so this method is
// 'unsafe' if called directly.
inline PROTOBUF_NDEBUG_INLINE static void InternalSwap(ArenaStringPtr* rhs,
Arena* rhs_arena,
ArenaStringPtr* lhs,
Arena* lhs_arena);
// Internal setter used only at parse time to directly set a donated string
// value.
void UnsafeSetTaggedPointer(TaggedPtr<std::string> value) {
tagged_ptr_ = value;
}
void UnsafeSetTaggedPointer(TaggedStringPtr value) { tagged_ptr_ = value; }
// Generated code only! An optimization, in certain cases the generated
// code is certain we can obtain a std::string with no default checks and
// tag tests.
std::string* UnsafeMutablePointer() PROTOBUF_RETURNS_NONNULL;
inline bool IsDefault(const std::string* default_value) const {
// Relies on the fact that kPtrTagString == 0, so if IsString(), ptr_ is the
// actual std::string pointer (and if !IsString(), ptr_ will never be equal
// to any aligned |default_value| pointer). The key is that we want to avoid
// masking in the fastpath const-pointer Get() case for non-arena code.
return tagged_ptr_.UnsafeGet() == default_value;
}
// Returns true if this instances holds an immutable default value.
inline bool IsDefault() const { return tagged_ptr_.IsDefault(); }
private:
TaggedPtr<std::string> tagged_ptr_;
template <typename... Args>
inline std::string* NewString(Arena* arena, Args&&... args) {
if (arena == nullptr) {
auto* s = new std::string(std::forward<Args>(args)...);
return tagged_ptr_.SetAllocated(s);
} else {
auto* s = Arena::Create<std::string>(arena, std::forward<Args>(args)...);
return tagged_ptr_.SetMutableArena(s);
}
}
bool IsDonatedString() const { return false; }
TaggedStringPtr tagged_ptr_;
bool IsFixedSizeArena() const { return false; }
// Swaps tagged pointer without debug hardening. This is to allow python
// protobuf to maintain pointer stability even in DEBUG builds.
@ -332,46 +376,81 @@ struct PROTOBUF_EXPORT ArenaStringPtr {
}
friend class ::google::protobuf::internal::SwapFieldHelper;
friend class TcParser;
// Slow paths.
// MutableSlow requires that !IsString() || IsDefault
// Variadic to support 0 args for EmptyDefault and 1 arg for LazyString.
// Variadic to support 0 args for empty default and 1 arg for LazyString.
template <typename... Lazy>
std::string* MutableSlow(::google::protobuf::Arena* arena, const Lazy&... lazy_default);
// Sets value to a newly allocated string and returns it
std::string* SetAndReturnNewString();
// Destroys the non-default string value out-of-line
void DestroyNoArenaSlowPath();
friend class EpsCopyInputStream;
};
inline void ArenaStringPtr::UnsafeSetDefault(const std::string* value) {
tagged_ptr_.Set(const_cast<std::string*>(value));
inline void ArenaStringPtr::InitDefault() {
tagged_ptr_ = TaggedStringPtr(&fixed_address_empty_string);
}
inline void ArenaStringPtr::InitExternal(const std::string* str) {
tagged_ptr_.SetDefault(str);
}
inline void ArenaStringPtr::InitAllocated(std::string* str, Arena* arena) {
if (arena != nullptr) {
tagged_ptr_.SetMutableArena(str);
arena->Own(str);
} else {
tagged_ptr_.SetAllocated(str);
}
}
inline void ArenaStringPtr::Set(const char* s, Arena* arena) {
Set(ConstStringParam{s}, arena);
}
inline void ArenaStringPtr::Set(const char* s, size_t n, Arena* arena) {
Set(ConstStringParam{s, n}, arena);
}
inline void ArenaStringPtr::SetBytes(ConstStringParam value, Arena* arena) {
Set(value, arena);
}
inline void ArenaStringPtr::SetBytes(std::string&& value, Arena* arena) {
Set(std::move(value), arena);
}
inline void ArenaStringPtr::SetBytes(const char* s, Arena* arena) {
Set(s, arena);
}
inline void ArenaStringPtr::SetBytes(const void* p, size_t n, Arena* arena) {
Set(ConstStringParam{static_cast<const char*>(p), n}, arena);
}
// Make sure rhs_arena allocated rhs, and lhs_arena allocated lhs.
inline PROTOBUF_NDEBUG_INLINE void ArenaStringPtr::InternalSwap( //
const std::string* default_value, //
ArenaStringPtr* rhs, Arena* rhs_arena, //
ArenaStringPtr* lhs, Arena* lhs_arena) {
// Silence unused variable warnings in release buildls.
(void)default_value;
(void)rhs_arena;
(void)lhs_arena;
std::swap(lhs->tagged_ptr_, rhs->tagged_ptr_);
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
auto force_realloc = [default_value](ArenaStringPtr* p, Arena* arena) {
if (p->IsDefault(default_value)) return;
auto force_realloc = [](ArenaStringPtr* p, Arena* arena) {
if (p->IsDefault()) return;
std::string* old_value = p->tagged_ptr_.Get();
std::string* new_value =
p->IsDonatedString()
p->IsFixedSizeArena()
? Arena::Create<std::string>(arena, *old_value)
: Arena::Create<std::string>(arena, std::move(*old_value));
if (arena == nullptr) delete old_value;
p->tagged_ptr_.Set(new_value);
if (arena == nullptr) {
delete old_value;
p->tagged_ptr_.SetAllocated(new_value);
} else {
p->tagged_ptr_.SetMutableArena(new_value);
}
};
// Because, at this point, tagged_ptr_ has been swapped, arena should also be
// swapped.
@ -385,29 +464,10 @@ inline void ArenaStringPtr::ClearNonDefaultToEmpty() {
tagged_ptr_.Get()->clear();
}
inline std::string* ArenaStringPtr::MutableNoArenaNoDefault(
const std::string* default_value) {
// VERY IMPORTANT for performance and code size: this will reduce to a member
// variable load, a pointer check (against |default_value|, in practice a
// static global) and a branch to the slowpath (which calls operator new and
// the ctor). DO NOT add any tagged-pointer operations here.
if (IsDefault(default_value)) {
return SetAndReturnNewString();
} else {
return UnsafeMutablePointer();
}
}
inline void ArenaStringPtr::DestroyNoArena(const std::string* default_value) {
if (!IsDefault(default_value)) {
DestroyNoArenaSlowPath();
}
}
inline std::string* ArenaStringPtr::UnsafeMutablePointer() {
GOOGLE_DCHECK(!tagged_ptr_.IsTagged());
GOOGLE_DCHECK(tagged_ptr_.UnsafeGet() != nullptr);
return tagged_ptr_.UnsafeGet();
GOOGLE_DCHECK(tagged_ptr_.IsMutable());
GOOGLE_DCHECK(tagged_ptr_.Get() != nullptr);
return tagged_ptr_.Get();
}

41
r5dev/thirdparty/protobuf/arenastring_unittest.cc vendored
View File

@ -34,6 +34,7 @@
#include <cstdlib>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include <thirdparty/protobuf/stubs/logging.h>
@ -54,8 +55,6 @@ namespace protobuf {
using internal::ArenaStringPtr;
using EmptyDefault = ArenaStringPtr::EmptyDefault;
const internal::LazyString nonempty_default{{{"default", 7}}, {nullptr}};
const std::string* empty_default = &internal::GetEmptyString();
@ -72,37 +71,36 @@ INSTANTIATE_TEST_SUITE_P(ArenaString, SingleArena, testing::Bool());
TEST_P(SingleArena, GetSet) {
auto arena = GetArena();
ArenaStringPtr field;
field.UnsafeSetDefault(empty_default);
field.InitDefault();
EXPECT_EQ("", field.Get());
field.Set(empty_default, "Test short", arena.get());
field.Set("Test short", arena.get());
EXPECT_EQ("Test short", field.Get());
field.Set(empty_default, "Test long long long long value", arena.get());
field.Set("Test long long long long value", arena.get());
EXPECT_EQ("Test long long long long value", field.Get());
field.Set(empty_default, "", arena.get());
field.Destroy(empty_default, arena.get());
field.Set("", arena.get());
field.Destroy();
}
TEST_P(SingleArena, MutableAccessor) {
auto arena = GetArena();
ArenaStringPtr field;
const std::string* empty_default = &internal::GetEmptyString();
field.UnsafeSetDefault(empty_default);
field.InitDefault();
std::string* mut = field.Mutable(EmptyDefault{}, arena.get());
EXPECT_EQ(mut, field.Mutable(EmptyDefault{}, arena.get()));
std::string* mut = field.Mutable(arena.get());
EXPECT_EQ(mut, field.Mutable(arena.get()));
EXPECT_EQ(mut, &field.Get());
EXPECT_NE(empty_default, mut);
EXPECT_EQ("", *mut);
*mut = "Test long long long long value"; // ensure string allocates storage
EXPECT_EQ("Test long long long long value", field.Get());
field.Destroy(empty_default, arena.get());
field.Destroy();
}
TEST_P(SingleArena, NullDefault) {
auto arena = GetArena();
ArenaStringPtr field;
field.UnsafeSetDefault(nullptr);
field.InitDefault();
std::string* mut = field.Mutable(nonempty_default, arena.get());
EXPECT_EQ(mut, field.Mutable(nonempty_default, arena.get()));
EXPECT_EQ(mut, &field.Get());
@ -110,7 +108,7 @@ TEST_P(SingleArena, NullDefault) {
EXPECT_EQ("default", *mut);
*mut = "Test long long long long value"; // ensure string allocates storage
EXPECT_EQ("Test long long long long value", field.Get());
field.Destroy(nullptr, arena.get());
field.Destroy();
}
class DualArena : public testing::TestWithParam<std::tuple<bool, bool>> {
@ -131,23 +129,22 @@ INSTANTIATE_TEST_SUITE_P(ArenaString, DualArena,
TEST_P(DualArena, Swap) {
auto lhs_arena = GetLhsArena();
ArenaStringPtr lhs;
lhs.UnsafeSetDefault(empty_default);
lhs.InitDefault();
ArenaStringPtr rhs;
rhs.UnsafeSetDefault(empty_default);
rhs.InitDefault();
{
auto rhs_arena = GetRhsArena();
lhs.Set(empty_default, "lhs value that has some heft", lhs_arena.get());
rhs.Set(empty_default, "rhs value that has some heft", rhs_arena.get());
ArenaStringPtr::InternalSwap(empty_default, //
&lhs, lhs_arena.get(), //
lhs.Set("lhs value that has some heft", lhs_arena.get());
rhs.Set("rhs value that has some heft", rhs_arena.get());
ArenaStringPtr::InternalSwap(&lhs, lhs_arena.get(), //
&rhs, rhs_arena.get());
EXPECT_EQ("rhs value that has some heft", lhs.Get());
EXPECT_EQ("lhs value that has some heft", rhs.Get());
lhs.Destroy(empty_default, rhs_arena.get());
lhs.Destroy();
}
EXPECT_EQ("lhs value that has some heft", rhs.Get());
rhs.Destroy(empty_default, lhs_arena.get());
rhs.Destroy();
}

177
r5dev/thirdparty/protobuf/arenaz_sampler.cc vendored Normal file
View File

@ -0,0 +1,177 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <thirdparty/protobuf/arenaz_sampler.h>
#include <atomic>
#include <cstdint>
#include <limits>
// Must be included last.
#include <thirdparty/protobuf/port_def.inc>
namespace google {
namespace protobuf {
namespace internal {
ThreadSafeArenazSampler& GlobalThreadSafeArenazSampler() {
static auto* sampler = new ThreadSafeArenazSampler();
return *sampler;
}
void UnsampleSlow(ThreadSafeArenaStats* info) {
GlobalThreadSafeArenazSampler().Unregister(info);
}
#if defined(PROTOBUF_ARENAZ_SAMPLE)
namespace {
PROTOBUF_CONSTINIT std::atomic<bool> g_arenaz_enabled{true};
PROTOBUF_CONSTINIT std::atomic<int32_t> g_arenaz_sample_parameter{1 << 10};
PROTOBUF_THREAD_LOCAL absl::profiling_internal::ExponentialBiased
g_exponential_biased_generator;
} // namespace
PROTOBUF_THREAD_LOCAL int64_t global_next_sample = 1LL << 10;
ThreadSafeArenaStats::ThreadSafeArenaStats() { PrepareForSampling(); }
ThreadSafeArenaStats::~ThreadSafeArenaStats() = default;
void ThreadSafeArenaStats::PrepareForSampling() {
num_allocations.store(0, std::memory_order_relaxed);
num_resets.store(0, std::memory_order_relaxed);
bytes_requested.store(0, std::memory_order_relaxed);
bytes_allocated.store(0, std::memory_order_relaxed);
bytes_wasted.store(0, std::memory_order_relaxed);
max_bytes_allocated.store(0, std::memory_order_relaxed);
thread_ids.store(0, std::memory_order_relaxed);
// The inliner makes hardcoded skip_count difficult (especially when combined
// with LTO). We use the ability to exclude stacks by regex when encoding
// instead.
depth = absl::GetStackTrace(stack, kMaxStackDepth, /* skip_count= */ 0);
}
void RecordResetSlow(ThreadSafeArenaStats* info) {
const size_t max_bytes =
info->max_bytes_allocated.load(std::memory_order_relaxed);
const size_t allocated_bytes =
info->bytes_allocated.load(std::memory_order_relaxed);
if (max_bytes < allocated_bytes) {
info->max_bytes_allocated.store(allocated_bytes);
}
info->bytes_requested.store(0, std::memory_order_relaxed);
info->bytes_allocated.store(0, std::memory_order_relaxed);
info->bytes_wasted.fetch_add(0, std::memory_order_relaxed);
info->num_allocations.fetch_add(0, std::memory_order_relaxed);
info->num_resets.fetch_add(1, std::memory_order_relaxed);
}
void RecordAllocateSlow(ThreadSafeArenaStats* info, size_t requested,
size_t allocated, size_t wasted) {
info->bytes_requested.fetch_add(requested, std::memory_order_relaxed);
info->bytes_allocated.fetch_add(allocated, std::memory_order_relaxed);
info->bytes_wasted.fetch_add(wasted, std::memory_order_relaxed);
info->num_allocations.fetch_add(1, std::memory_order_relaxed);
const uint64_t tid = (1ULL << (GetCachedTID() % 63));
const uint64_t thread_ids = info->thread_ids.load(std::memory_order_relaxed);
if (!(thread_ids & tid)) {
info->thread_ids.store(thread_ids | tid, std::memory_order_relaxed);
}
}
ThreadSafeArenaStats* SampleSlow(int64_t* next_sample) {
bool first = *next_sample < 0;
*next_sample = g_exponential_biased_generator.GetStride(
g_arenaz_sample_parameter.load(std::memory_order_relaxed));
// Small values of interval are equivalent to just sampling next time.
ABSL_ASSERT(*next_sample >= 1);
// g_arenaz_enabled can be dynamically flipped, we need to set a threshold low
// enough that we will start sampling in a reasonable time, so we just use the
// default sampling rate.
if (!g_arenaz_enabled.load(std::memory_order_relaxed)) return nullptr;
// We will only be negative on our first count, so we should just retry in
// that case.
if (first) {
if (PROTOBUF_PREDICT_TRUE(--*next_sample > 0)) return nullptr;
return SampleSlow(next_sample);
}
return GlobalThreadSafeArenazSampler().Register();
}
void SetThreadSafeArenazEnabled(bool enabled) {
g_arenaz_enabled.store(enabled, std::memory_order_release);
}
void SetThreadSafeArenazSampleParameter(int32_t rate) {
if (rate > 0) {
g_arenaz_sample_parameter.store(rate, std::memory_order_release);
} else {
ABSL_RAW_LOG(ERROR, "Invalid thread safe arenaz sample rate: %lld",
static_cast<long long>(rate)); // NOLINT(runtime/int)
}
}
void SetThreadSafeArenazMaxSamples(int32_t max) {
if (max > 0) {
GlobalThreadSafeArenazSampler().SetMaxSamples(max);
} else {
ABSL_RAW_LOG(ERROR, "Invalid thread safe arenaz max samples: %lld",
static_cast<long long>(max)); // NOLINT(runtime/int)
}
}
void SetThreadSafeArenazGlobalNextSample(int64_t next_sample) {
if (next_sample >= 0) {
global_next_sample = next_sample;
} else {
ABSL_RAW_LOG(ERROR, "Invalid thread safe arenaz next sample: %lld",
static_cast<long long>(next_sample)); // NOLINT(runtime/int)
}
}
#else
ThreadSafeArenaStats* SampleSlow(int64_t* next_sample) {
*next_sample = std::numeric_limits<int64_t>::max();
return nullptr;
}
void SetThreadSafeArenazEnabled(bool enabled) {}
void SetThreadSafeArenazSampleParameter(int32_t rate) {}
void SetThreadSafeArenazMaxSamples(int32_t max) {}
void SetThreadSafeArenazGlobalNextSample(int64_t next_sample) {}
#endif // defined(PROTOBUF_ARENAZ_SAMPLE)
} // namespace internal
} // namespace protobuf
} // namespace google

207
r5dev/thirdparty/protobuf/arenaz_sampler.h vendored Normal file
View File

@ -0,0 +1,207 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef GOOGLE_PROTOBUF_SRC_GOOGLE_PROTOBUF_ARENAZ_SAMPLER_H__
#define GOOGLE_PROTOBUF_SRC_GOOGLE_PROTOBUF_ARENAZ_SAMPLER_H__
#include <atomic>
#include <cstddef>
#include <cstdint>
// Must be included last.
#include <thirdparty/protobuf/port_def.inc>
namespace google {
namespace protobuf {
namespace internal {
#if defined(PROTOBUF_ARENAZ_SAMPLE)
struct ThreadSafeArenaStats;
void RecordResetSlow(ThreadSafeArenaStats* info);
void RecordAllocateSlow(ThreadSafeArenaStats* info, size_t requested,
size_t allocated, size_t wasted);
// Stores information about a sampled thread safe arena. All mutations to this
// *must* be made through `Record*` functions below. All reads from this *must*
// only occur in the callback to `ThreadSafeArenazSampler::Iterate`.
struct ThreadSafeArenaStats
: public absl::profiling_internal::Sample<ThreadSafeArenaStats> {
// Constructs the object but does not fill in any fields.
ThreadSafeArenaStats();
~ThreadSafeArenaStats();
// Puts the object into a clean state, fills in the logically `const` members,
// blocking for any readers that are currently sampling the object.
void PrepareForSampling() ABSL_EXCLUSIVE_LOCKS_REQUIRED(init_mu);
// These fields are mutated by the various Record* APIs and need to be
// thread-safe.
std::atomic<int> num_allocations;
std::atomic<int> num_resets;
std::atomic<size_t> bytes_requested;
std::atomic<size_t> bytes_allocated;
std::atomic<size_t> bytes_wasted;
// Records the largest size an arena ever had. Maintained across resets.
std::atomic<size_t> max_bytes_allocated;
// Bit i when set to 1 indicates that a thread with tid % 63 = i accessed the
// underlying arena. The field is maintained across resets.
std::atomic<uint64_t> thread_ids;
// All of the fields below are set by `PrepareForSampling`, they must not
// be mutated in `Record*` functions. They are logically `const` in that
// sense. These are guarded by init_mu, but that is not externalized to
// clients, who can only read them during
// `ThreadSafeArenazSampler::Iterate` which will hold the lock.
static constexpr int kMaxStackDepth = 64;
int32_t depth;
void* stack[kMaxStackDepth];
static void RecordAllocateStats(ThreadSafeArenaStats* info, size_t requested,
size_t allocated, size_t wasted) {
if (PROTOBUF_PREDICT_TRUE(info == nullptr)) return;
RecordAllocateSlow(info, requested, allocated, wasted);
}
};
ThreadSafeArenaStats* SampleSlow(int64_t* next_sample);
void UnsampleSlow(ThreadSafeArenaStats* info);
class ThreadSafeArenaStatsHandle {
public:
explicit ThreadSafeArenaStatsHandle() = default;
explicit ThreadSafeArenaStatsHandle(ThreadSafeArenaStats* info)
: info_(info) {}
~ThreadSafeArenaStatsHandle() {
if (PROTOBUF_PREDICT_TRUE(info_ == nullptr)) return;
UnsampleSlow(info_);
}
ThreadSafeArenaStatsHandle(ThreadSafeArenaStatsHandle&& other) noexcept
: info_(absl::exchange(other.info_, nullptr)) {}
ThreadSafeArenaStatsHandle& operator=(
ThreadSafeArenaStatsHandle&& other) noexcept {
if (PROTOBUF_PREDICT_FALSE(info_ != nullptr)) {
UnsampleSlow(info_);
}
info_ = absl::exchange(other.info_, nullptr);
return *this;
}
void RecordReset() {
if (PROTOBUF_PREDICT_TRUE(info_ == nullptr)) return;
RecordResetSlow(info_);
}
ThreadSafeArenaStats* MutableStats() { return info_; }
friend void swap(ThreadSafeArenaStatsHandle& lhs,
ThreadSafeArenaStatsHandle& rhs) {
std::swap(lhs.info_, rhs.info_);
}
friend class ThreadSafeArenaStatsHandlePeer;
private:
ThreadSafeArenaStats* info_ = nullptr;
};
using ThreadSafeArenazSampler =
::absl::profiling_internal::SampleRecorder<ThreadSafeArenaStats>;
extern PROTOBUF_THREAD_LOCAL int64_t global_next_sample;
// Returns an RAII sampling handle that manages registration and unregistation
// with the global sampler.
inline ThreadSafeArenaStatsHandle Sample() {
if (PROTOBUF_PREDICT_TRUE(--global_next_sample > 0)) {
return ThreadSafeArenaStatsHandle(nullptr);
}
return ThreadSafeArenaStatsHandle(SampleSlow(&global_next_sample));
}
#else
struct ThreadSafeArenaStats {
static void RecordAllocateStats(ThreadSafeArenaStats*, size_t /*requested*/,
size_t /*allocated*/, size_t /*wasted*/) {}
};
ThreadSafeArenaStats* SampleSlow(int64_t* next_sample);
void UnsampleSlow(ThreadSafeArenaStats* info);
class ThreadSafeArenaStatsHandle {
public:
explicit ThreadSafeArenaStatsHandle() = default;
explicit ThreadSafeArenaStatsHandle(ThreadSafeArenaStats*) {}
void RecordReset() {}
ThreadSafeArenaStats* MutableStats() { return nullptr; }
friend void swap(ThreadSafeArenaStatsHandle&, ThreadSafeArenaStatsHandle&) {}
private:
friend class ThreadSafeArenaStatsHandlePeer;
};
class ThreadSafeArenazSampler {
public:
void Unregister(ThreadSafeArenaStats*) {}
void SetMaxSamples(int32_t) {}
};
// Returns an RAII sampling handle that manages registration and unregistation
// with the global sampler.
inline ThreadSafeArenaStatsHandle Sample() {
return ThreadSafeArenaStatsHandle(nullptr);
}
#endif // defined(PROTOBUF_ARENAZ_SAMPLE)
// Returns a global Sampler.
ThreadSafeArenazSampler& GlobalThreadSafeArenazSampler();
// Enables or disables sampling for thread safe arenas.
void SetThreadSafeArenazEnabled(bool enabled);
// Sets the rate at which thread safe arena will be sampled.
void SetThreadSafeArenazSampleParameter(int32_t rate);
// Sets a soft max for the number of samples that will be kept.
void SetThreadSafeArenazMaxSamples(int32_t max);
// Sets the current value for when arenas should be next sampled.
void SetThreadSafeArenazGlobalNextSample(int64_t next_sample);
} // namespace internal
} // namespace protobuf
} // namespace google
#include <thirdparty/protobuf/port_undef.inc>
#endif // GOOGLE_PROTOBUF_SRC_PROTOBUF_ARENAZ_SAMPLER_H__

382
r5dev/thirdparty/protobuf/arenaz_sampler_test.cc vendored Normal file
View File

@ -0,0 +1,382 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <thirdparty/protobuf/arenaz_sampler.h>
#include <memory>
#include <random>
#include <vector>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <thirdparty/protobuf/stubs/strutil.h>
// Must be included last.
#include <thirdparty/protobuf/port_def.inc>
namespace google {
namespace protobuf {
namespace internal {
#if defined(PROTOBUF_ARENAZ_SAMPLE)
class ThreadSafeArenaStatsHandlePeer {
public:
static bool IsSampled(const ThreadSafeArenaStatsHandle& h) {
return h.info_ != nullptr;
}
static ThreadSafeArenaStats* GetInfo(ThreadSafeArenaStatsHandle* h) {
return h->info_;
}
};
std::vector<size_t> GetBytesAllocated(ThreadSafeArenazSampler* s) {
std::vector<size_t> res;
s->Iterate([&](const ThreadSafeArenaStats& info) {
res.push_back(info.bytes_allocated.load(std::memory_order_acquire));
});
return res;
}
ThreadSafeArenaStats* Register(ThreadSafeArenazSampler* s, size_t size) {
auto* info = s->Register();
assert(info != nullptr);
info->bytes_allocated.store(size);
return info;
}
#endif // defined(PROTOBUF_ARENAZ_SAMPLE)
namespace {
#if defined(PROTOBUF_ARENAZ_SAMPLE)
TEST(ThreadSafeArenaStatsTest, PrepareForSampling) {
ThreadSafeArenaStats info;
MutexLock l(&info.init_mu);
info.PrepareForSampling();
EXPECT_EQ(info.num_allocations.load(), 0);
EXPECT_EQ(info.num_resets.load(), 0);
EXPECT_EQ(info.bytes_requested.load(), 0);
EXPECT_EQ(info.bytes_allocated.load(), 0);
EXPECT_EQ(info.bytes_wasted.load(), 0);
EXPECT_EQ(info.max_bytes_allocated.load(), 0);
info.num_allocations.store(1, std::memory_order_relaxed);
info.num_resets.store(1, std::memory_order_relaxed);
info.bytes_requested.store(1, std::memory_order_relaxed);
info.bytes_allocated.store(1, std::memory_order_relaxed);
info.bytes_wasted.store(1, std::memory_order_relaxed);
info.max_bytes_allocated.store(1, std::memory_order_relaxed);
info.PrepareForSampling();
EXPECT_EQ(info.num_allocations.load(), 0);
EXPECT_EQ(info.num_resets.load(), 0);
EXPECT_EQ(info.bytes_requested.load(), 0);
EXPECT_EQ(info.bytes_allocated.load(), 0);
EXPECT_EQ(info.bytes_wasted.load(), 0);
EXPECT_EQ(info.max_bytes_allocated.load(), 0);
}
TEST(ThreadSafeArenaStatsTest, RecordAllocateSlow) {
ThreadSafeArenaStats info;
MutexLock l(&info.init_mu);
info.PrepareForSampling();
RecordAllocateSlow(&info, /*requested=*/100, /*allocated=*/128, /*wasted=*/0);
EXPECT_EQ(info.num_allocations.load(), 1);
EXPECT_EQ(info.num_resets.load(), 0);
EXPECT_EQ(info.bytes_requested.load(), 100);
EXPECT_EQ(info.bytes_allocated.load(), 128);
EXPECT_EQ(info.bytes_wasted.load(), 0);
EXPECT_EQ(info.max_bytes_allocated.load(), 0);
RecordAllocateSlow(&info, /*requested=*/100, /*allocated=*/256,
/*wasted=*/28);
EXPECT_EQ(info.num_allocations.load(), 2);
EXPECT_EQ(info.num_resets.load(), 0);
EXPECT_EQ(info.bytes_requested.load(), 200);
EXPECT_EQ(info.bytes_allocated.load(), 384);
EXPECT_EQ(info.bytes_wasted.load(), 28);
EXPECT_EQ(info.max_bytes_allocated.load(), 0);
}
TEST(ThreadSafeArenaStatsTest, RecordResetSlow) {
ThreadSafeArenaStats info;
MutexLock l(&info.init_mu);
info.PrepareForSampling();
EXPECT_EQ(info.num_resets.load(), 0);
EXPECT_EQ(info.bytes_allocated.load(), 0);
RecordAllocateSlow(&info, /*requested=*/100, /*allocated=*/128, /*wasted=*/0);
EXPECT_EQ(info.num_resets.load(), 0);
EXPECT_EQ(info.bytes_allocated.load(), 128);
RecordResetSlow(&info);
EXPECT_EQ(info.num_resets.load(), 1);
EXPECT_EQ(info.bytes_allocated.load(), 0);
}
TEST(ThreadSafeArenazSamplerTest, SmallSampleParameter) {
SetThreadSafeArenazEnabled(true);
SetThreadSafeArenazSampleParameter(100);
for (int i = 0; i < 1000; ++i) {
int64_t next_sample = 0;
ThreadSafeArenaStats* sample = SampleSlow(&next_sample);
EXPECT_GT(next_sample, 0);
EXPECT_NE(sample, nullptr);
UnsampleSlow(sample);
}
}
TEST(ThreadSafeArenazSamplerTest, LargeSampleParameter) {
SetThreadSafeArenazEnabled(true);
SetThreadSafeArenazSampleParameter(std::numeric_limits<int32_t>::max());
for (int i = 0; i < 1000; ++i) {
int64_t next_sample = 0;
ThreadSafeArenaStats* sample = SampleSlow(&next_sample);
EXPECT_GT(next_sample, 0);
EXPECT_NE(sample, nullptr);
UnsampleSlow(sample);
}
}
TEST(ThreadSafeArenazSamplerTest, Sample) {
SetThreadSafeArenazEnabled(true);
SetThreadSafeArenazSampleParameter(100);
SetThreadSafeArenazGlobalNextSample(0);
int64_t num_sampled = 0;
int64_t total = 0;
double sample_rate = 0.0;
for (int i = 0; i < 1000000; ++i) {
ThreadSafeArenaStatsHandle h = Sample();
++total;
if (ThreadSafeArenaStatsHandlePeer::IsSampled(h)) {
++num_sampled;
}
sample_rate = static_cast<double>(num_sampled) / total;
if (0.005 < sample_rate && sample_rate < 0.015) break;
}
EXPECT_NEAR(sample_rate, 0.01, 0.005);
}
TEST(ThreadSafeArenazSamplerTest, Handle) {
auto& sampler = GlobalThreadSafeArenazSampler();
ThreadSafeArenaStatsHandle h(sampler.Register());
auto* info = ThreadSafeArenaStatsHandlePeer::GetInfo(&h);
info->bytes_allocated.store(0x12345678, std::memory_order_relaxed);
bool found = false;
sampler.Iterate([&](const ThreadSafeArenaStats& h) {
if (&h == info) {
EXPECT_EQ(h.bytes_allocated.load(), 0x12345678);
found = true;
}
});
EXPECT_TRUE(found);
h = ThreadSafeArenaStatsHandle();
found = false;
sampler.Iterate([&](const ThreadSafeArenaStats& h) {
if (&h == info) {
// this will only happen if some other thread has resurrected the info
// the old handle was using.
if (h.bytes_allocated.load() == 0x12345678) {
found = true;
}
}
});
EXPECT_FALSE(found);
}
TEST(ThreadSafeArenazSamplerTest, Registration) {
ThreadSafeArenazSampler sampler;
auto* info1 = Register(&sampler, 1);
EXPECT_THAT(GetBytesAllocated(&sampler), UnorderedElementsAre(1));
auto* info2 = Register(&sampler, 2);
EXPECT_THAT(GetBytesAllocated(&sampler), UnorderedElementsAre(1, 2));
info1->bytes_allocated.store(3);
EXPECT_THAT(GetBytesAllocated(&sampler), UnorderedElementsAre(3, 2));
sampler.Unregister(info1);
sampler.Unregister(info2);
}
TEST(ThreadSafeArenazSamplerTest, Unregistration) {
ThreadSafeArenazSampler sampler;
std::vector<ThreadSafeArenaStats*> infos;
for (size_t i = 0; i < 3; ++i) {
infos.push_back(Register(&sampler, i));
}
EXPECT_THAT(GetBytesAllocated(&sampler), UnorderedElementsAre(0, 1, 2));
sampler.Unregister(infos[1]);
EXPECT_THAT(GetBytesAllocated(&sampler), UnorderedElementsAre(0, 2));
infos.push_back(Register(&sampler, 3));
infos.push_back(Register(&sampler, 4));
EXPECT_THAT(GetBytesAllocated(&sampler), UnorderedElementsAre(0, 2, 3, 4));
sampler.Unregister(infos[3]);
EXPECT_THAT(GetBytesAllocated(&sampler), UnorderedElementsAre(0, 2, 4));
sampler.Unregister(infos[0]);
sampler.Unregister(infos[2]);
sampler.Unregister(infos[4]);
EXPECT_THAT(GetBytesAllocated(&sampler), IsEmpty());
}
TEST(ThreadSafeArenazSamplerTest, MultiThreaded) {
ThreadSafeArenazSampler sampler;
absl::Notification stop;
ThreadPool pool(10);
for (int i = 0; i < 10; ++i) {
pool.Schedule([&sampler, &stop]() {
std::random_device rd;
std::mt19937 gen(rd());
std::vector<ThreadSafeArenaStats*> infoz;
while (!stop.HasBeenNotified()) {
if (infoz.empty()) {
infoz.push_back(sampler.Register());
}
switch (std::uniform_int_distribution<>(0, 1)(gen)) {
case 0: {
infoz.push_back(sampler.Register());
break;
}
case 1: {
size_t p =
std::uniform_int_distribution<>(0, infoz.size() - 1)(gen);
ThreadSafeArenaStats* info = infoz[p];
infoz[p] = infoz.back();
infoz.pop_back();
sampler.Unregister(info);
break;
}
}
}
});
}
// The threads will hammer away. Give it a little bit of time for tsan to
// spot errors.
absl::SleepFor(absl::Seconds(3));
stop.Notify();
}
TEST(ThreadSafeArenazSamplerTest, Callback) {
ThreadSafeArenazSampler sampler;
auto* info1 = Register(&sampler, 1);
auto* info2 = Register(&sampler, 2);
static const ThreadSafeArenaStats* expected;
auto callback = [](const ThreadSafeArenaStats& info) {
// We can't use `info` outside of this callback because the object will be
// disposed as soon as we return from here.
EXPECT_EQ(&info, expected);
};
// Set the callback.
EXPECT_EQ(sampler.SetDisposeCallback(callback), nullptr);
expected = info1;
sampler.Unregister(info1);
// Unset the callback.
EXPECT_EQ(callback, sampler.SetDisposeCallback(nullptr));
expected = nullptr; // no more calls.
sampler.Unregister(info2);
}
class ThreadSafeArenazSamplerTestThread : public Thread {
protected:
void Run() override {
google::protobuf::ArenaSafeUniquePtr<
protobuf_test_messages::proto2::TestAllTypesProto2>
message = google::protobuf::MakeArenaSafeUnique<
protobuf_test_messages::proto2::TestAllTypesProto2>(arena_);
GOOGLE_CHECK(message != nullptr);
// Signal that a message on the arena has been created. This should create
// a SerialArena for this thread.
if (barrier_->Block()) {
delete barrier_;
}
}
public:
ThreadSafeArenazSamplerTestThread(const thread::Options& options,
StringPiece name,
google::protobuf::Arena* arena,
absl::Barrier* barrier)
: Thread(options, name), arena_(arena), barrier_(barrier) {}
private:
google::protobuf::Arena* arena_;
absl::Barrier* barrier_;
};
TEST(ThreadSafeArenazSamplerTest, MultiThread) {
SetThreadSafeArenazEnabled(true);
// Setting 1 as the parameter value means one in every two arenas would be
// sampled, on average.
SetThreadSafeArenazSampleParameter(1);
SetThreadSafeArenazGlobalNextSample(0);
auto& sampler = GlobalThreadSafeArenazSampler();
int count = 0;
for (int i = 0; i < 10; ++i) {
const int kNumThreads = 10;
absl::Barrier* barrier = new absl::Barrier(kNumThreads + 1);
google::protobuf::Arena arena;
thread::Options options;
options.set_joinable(true);
std::vector<std::unique_ptr<ThreadSafeArenazSamplerTestThread>> threads;
for (int i = 0; i < kNumThreads; i++) {
auto t = std::make_unique<ThreadSafeArenazSamplerTestThread>(
options, StrCat("thread", i), &arena, barrier);
t->Start();
threads.push_back(std::move(t));
}
// Wait till each thread has created a message on the arena.
if (barrier->Block()) {
delete barrier;
}
sampler.Iterate([&](const ThreadSafeArenaStats& h) { ++count; });
for (int i = 0; i < kNumThreads; i++) {
threads[i]->Join();
}
}
EXPECT_GT(count, 0);
}
#endif // defined(PROTOBUF_ARENAZ_SAMPLE)
} // namespace
} // namespace internal
} // namespace protobuf
} // namespace google

7
r5dev/thirdparty/protobuf/compiler/annotation_test_util.cc vendored
View File

@ -58,9 +58,8 @@ class DescriptorCapturingGenerator : public CodeGenerator {
explicit DescriptorCapturingGenerator(FileDescriptorProto* file)
: file_(file) {}
virtual bool Generate(const FileDescriptor* file,
const std::string& parameter, GeneratorContext* context,
std::string* error) const {
bool Generate(const FileDescriptor* file, const std::string& parameter,
GeneratorContext* context, std::string* error) const override {
file->CopyTo(file_);
return true;
}
@ -128,7 +127,7 @@ const GeneratedCodeInfo::Annotation* FindAnnotationOnPath(
std::vector<const GeneratedCodeInfo::Annotation*> annotations;
FindAnnotationsOnPath(info, source_file, path, &annotations);
if (annotations.empty()) {
return NULL;
return nullptr;
}
return annotations[0];
}

4
r5dev/thirdparty/protobuf/compiler/annotation_test_util.h vendored
View File

@ -78,7 +78,7 @@ bool RunProtoCompiler(const std::string& filename,
bool DecodeMetadata(const std::string& path, GeneratedCodeInfo* info);
// Finds all of the Annotations for a given source file and path.
// See Location.path in https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/descriptor.proto for
// See Location.path in https://github.com/protocolbuffers/protobuf/blob/main/src/google/protobuf/descriptor.proto for
// explanation of what path vector is.
void FindAnnotationsOnPath(
const GeneratedCodeInfo& info, const std::string& source_file,
@ -88,7 +88,7 @@ void FindAnnotationsOnPath(
// Finds the Annotation for a given source file and path (or returns null if it
// couldn't). If there are several annotations for given path, returns the first
// one. See Location.path in
// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/descriptor.proto for explanation of what path
// https://github.com/protocolbuffers/protobuf/blob/main/src/google/protobuf/descriptor.proto for explanation of what path
// vector is.
const GeneratedCodeInfo::Annotation* FindAnnotationOnPath(
const GeneratedCodeInfo& info, const std::string& source_file,

4
r5dev/thirdparty/protobuf/compiler/code_generator.cc vendored
View File

@ -76,13 +76,13 @@ GeneratorContext::~GeneratorContext() {}
io::ZeroCopyOutputStream* GeneratorContext::OpenForAppend(
const std::string& filename) {
return NULL;
return nullptr;
}
io::ZeroCopyOutputStream* GeneratorContext::OpenForInsert(
const std::string& filename, const std::string& insertion_point) {
GOOGLE_LOG(FATAL) << "This GeneratorContext does not support insertion.";
return NULL; // make compiler happy
return nullptr; // make compiler happy
}
io::ZeroCopyOutputStream* GeneratorContext::OpenForInsertWithGeneratedCodeInfo(

5
r5dev/thirdparty/protobuf/compiler/code_generator.h vendored
View File

@ -43,6 +43,7 @@
#include <vector>
#include <thirdparty/protobuf/stubs/common.h>
// Must be included last.
#include <thirdparty/protobuf/port_def.inc>
namespace google {
@ -188,9 +189,9 @@ typedef GeneratorContext OutputDirectory;
// Several code generators treat the parameter argument as holding a
// list of options separated by commas. This helper function parses
// a set of comma-delimited name/value pairs: e.g.,
// "foo=bar,baz,qux=corge"
// "foo=bar,baz,moo=corge"
// parses to the pairs:
// ("foo", "bar"), ("baz", ""), ("qux", "corge")
// ("foo", "bar"), ("baz", ""), ("moo", "corge")
PROTOC_EXPORT void ParseGeneratorParameter(
const std::string&, std::vector<std::pair<std::string, std::string> >*);

74
r5dev/thirdparty/protobuf/compiler/command_line_interface.cc vendored
View File

@ -34,8 +34,6 @@
#include <thirdparty/protobuf/compiler/command_line_interface.h>
#include <cstdint>
#include <thirdparty/protobuf/stubs/platform_macros.h>
#include <stdio.h>
@ -53,10 +51,11 @@
#endif
#include <ctype.h>
#include <errno.h>
#include <fstream>
#include <iostream>
#include <limits.h> //For PATH_MAX
#include <limits.h> // For PATH_MAX
#include <memory>
@ -68,25 +67,26 @@
#include <thirdparty/protobuf/stubs/common.h>
#include <thirdparty/protobuf/stubs/logging.h>
#include <thirdparty/protobuf/stubs/stringprintf.h>
#include <thirdparty/protobuf/compiler/subprocess.h>
#include <thirdparty/protobuf/compiler/zip_writer.h>
#include <thirdparty/protobuf/compiler/plugin.pb.h>
#include <thirdparty/protobuf/stubs/strutil.h>
#include <thirdparty/protobuf/stubs/stringprintf.h>
#include <thirdparty/protobuf/stubs/substitute.h>
#include <thirdparty/protobuf/compiler/code_generator.h>
#include <thirdparty/protobuf/compiler/importer.h>
#include <thirdparty/protobuf/io/coded_stream.h>
#include <thirdparty/protobuf/io/printer.h>
#include <thirdparty/protobuf/io/zero_copy_stream_impl.h>
#include <thirdparty/protobuf/compiler/zip_writer.h>
#include <thirdparty/protobuf/descriptor.h>
#include <thirdparty/protobuf/dynamic_message.h>
#include <thirdparty/protobuf/text_format.h>
#include <thirdparty/protobuf/stubs/strutil.h>
#include <thirdparty/protobuf/stubs/substitute.h>
#include <thirdparty/protobuf/io/coded_stream.h>
#include <thirdparty/protobuf/io/io_win32.h>
#include <thirdparty/protobuf/io/printer.h>
#include <thirdparty/protobuf/io/zero_copy_stream_impl.h>
#include <thirdparty/protobuf/text_format.h>
#include <thirdparty/protobuf/stubs/map_util.h>
#include <thirdparty/protobuf/stubs/stl_util.h>
// Must be included last.
#include <thirdparty/protobuf/port_def.inc>
namespace google {
@ -195,7 +195,7 @@ bool TryCreateParentDirectory(const std::string& prefix,
bool GetProtocAbsolutePath(std::string* path) {
#ifdef _WIN32
char buffer[MAX_PATH];
int len = GetModuleFileNameA(NULL, buffer, MAX_PATH);
int len = GetModuleFileNameA(nullptr, buffer, MAX_PATH);
#elif defined(__APPLE__)
char buffer[PATH_MAX];
int len = 0;
@ -210,7 +210,7 @@ bool GetProtocAbsolutePath(std::string* path) {
char buffer[PATH_MAX];
size_t len = PATH_MAX;
int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1};
if (sysctl(mib, 4, &buffer, &len, NULL, 0) != 0) {
if (sysctl(mib, 4, &buffer, &len, nullptr, 0) != 0) {
len = 0;
}
#else
@ -289,12 +289,12 @@ class CommandLineInterface::ErrorPrinter
public io::ErrorCollector,
public DescriptorPool::ErrorCollector {
public:
ErrorPrinter(ErrorFormat format, DiskSourceTree* tree = NULL)
ErrorPrinter(ErrorFormat format, DiskSourceTree* tree = nullptr)
: format_(format),
tree_(tree),
found_errors_(false),
found_warnings_(false) {}
~ErrorPrinter() {}
~ErrorPrinter() override {}
// implements MultiFileErrorCollector ------------------------------
void AddError(const std::string& filename, int line, int column,
@ -341,8 +341,8 @@ class CommandLineInterface::ErrorPrinter
std::ostream& out) {
// Print full path when running under MSVS
std::string dfile;
if (format_ == CommandLineInterface::ERROR_FORMAT_MSVS && tree_ != NULL &&
tree_->VirtualFileToDiskFile(filename, &dfile)) {
if (format_ == CommandLineInterface::ERROR_FORMAT_MSVS &&
tree_ != nullptr && tree_->VirtualFileToDiskFile(filename, &dfile)) {
out << dfile;
} else {
out << filename;
@ -434,7 +434,7 @@ class CommandLineInterface::MemoryOutputStream
const std::string& filename,
const std::string& insertion_point,
const google::protobuf::GeneratedCodeInfo& info);
virtual ~MemoryOutputStream();
~MemoryOutputStream() override;
// implements ZeroCopyOutputStream ---------------------------------
bool Next(void** data, int* size) override {
@ -1116,7 +1116,7 @@ int CommandLineInterface::Run(int argc, const char* const argv[]) {
FileDescriptorProto file;
file.set_name("empty_message.proto");
file.add_message_type()->set_name("EmptyMessage");
GOOGLE_CHECK(pool.BuildFile(file) != NULL);
GOOGLE_CHECK(pool.BuildFile(file) != nullptr);
codec_type_ = "EmptyMessage";
if (!EncodeOrDecode(&pool)) {
return 1;
@ -1270,7 +1270,7 @@ bool CommandLineInterface::ParseInputFiles(
// Import the file.
const FileDescriptor* parsed_file =
descriptor_pool->FindFileByName(input_file);
if (parsed_file == NULL) {
if (parsed_file == nullptr) {
result = false;
break;
}
@ -1496,7 +1496,7 @@ CommandLineInterface::ParseArgumentStatus CommandLineInterface::ParseArguments(
for (std::vector<OutputDirective>::const_iterator j =
output_directives_.begin();
j != output_directives_.end(); ++j) {
if (j->generator == NULL) {
if (j->generator == nullptr) {
std::string plugin_name = PluginName(plugin_prefix_, j->name);
if (plugin_name == i->first) {
foundImplicitPlugin = true;
@ -1606,7 +1606,7 @@ bool CommandLineInterface::ParseArgument(const char* arg, std::string* name,
// Two dashes: Multi-character name, with '=' separating name and
// value.
const char* equals_pos = strchr(arg, '=');
if (equals_pos != NULL) {
if (equals_pos != nullptr) {
*name = std::string(arg, equals_pos - arg);
*value = equals_pos + 1;
parsed_value = true;
@ -1674,8 +1674,9 @@ CommandLineInterface::InterpretArgument(const std::string& name,
// On Windows, the shell (typically cmd.exe) does not expand wildcards in
// file names (e.g. foo\*.proto), so we do it ourselves.
switch (google::protobuf::io::win32::ExpandWildcards(
value,
[this](const string& path) { this->input_files_.push_back(path); })) {
value, [this](const std::string& path) {
this->input_files_.push_back(path);
})) {
case google::protobuf::io::win32::ExpandWildcardsResult::kSuccess:
break;
case google::protobuf::io::win32::ExpandWildcardsResult::
@ -1946,11 +1947,11 @@ CommandLineInterface::InterpretArgument(const std::string& name,
// Some other flag. Look it up in the generators list.
const GeneratorInfo* generator_info =
FindOrNull(generators_by_flag_name_, name);
if (generator_info == NULL &&
if (generator_info == nullptr &&
(plugin_prefix_.empty() || !HasSuffixString(name, "_out"))) {
// Check if it's a generator option flag.
generator_info = FindOrNull(generators_by_option_name_, name);
if (generator_info != NULL) {
if (generator_info != nullptr) {
std::string* parameters =
&generator_parameters_[generator_info->flag_name];
if (!parameters->empty()) {
@ -1979,8 +1980,8 @@ CommandLineInterface::InterpretArgument(const std::string& name,
OutputDirective directive;
directive.name = name;
if (generator_info == NULL) {
directive.generator = NULL;
if (generator_info == nullptr) {
directive.generator = nullptr;
} else {
directive.generator = generator_info->generator;
}
@ -2136,7 +2137,7 @@ bool CommandLineInterface::GenerateOutput(
GeneratorContext* generator_context) {
// Call the generator.
std::string error;
if (output_directive.generator == NULL) {
if (output_directive.generator == nullptr) {
// This is a plugin.
GOOGLE_CHECK(HasPrefixString(output_directive.name, "--") &&
HasSuffixString(output_directive.name, "_out"))
@ -2208,6 +2209,10 @@ bool CommandLineInterface::GenerateDependencyManifestFile(
}
}
if (!descriptor_set_out_name_.empty()) {
output_filenames.push_back(descriptor_set_out_name_);
}
int fd;
do {
fd = open(dependency_out_name_.c_str(),
@ -2304,7 +2309,7 @@ bool CommandLineInterface::GeneratePluginOutput(
if (!output_file.insertion_point().empty()) {
std::string filename = output_file.name();
// Open a file for insert.
// We reset current_output to NULL first so that the old file is closed
// We reset current_output to nullptr first so that the old file is closed
// before the new one is opened.
current_output.reset();
current_output.reset(
@ -2313,11 +2318,11 @@ bool CommandLineInterface::GeneratePluginOutput(
output_file.generated_code_info()));
} else if (!output_file.name().empty()) {
// Starting a new file. Open it.
// We reset current_output to NULL first so that the old file is closed
// We reset current_output to nullptr first so that the old file is closed
// before the new one is opened.
current_output.reset();
current_output.reset(generator_context->Open(output_file.name()));
} else if (current_output == NULL) {
} else if (current_output == nullptr) {
*error = strings::Substitute(
"$0: First file chunk returned by plugin did not specify a file "
"name.",
@ -2347,7 +2352,7 @@ bool CommandLineInterface::GeneratePluginOutput(
bool CommandLineInterface::EncodeOrDecode(const DescriptorPool* pool) {
// Look up the type.
const Descriptor* type = pool->FindMessageTypeByName(codec_type_);
if (type == NULL) {
if (type == nullptr) {
std::cerr << "Type not defined: " << codec_type_ << std::endl;
return false;
}
@ -2586,7 +2591,8 @@ void FormatFreeFieldNumbers(const std::string& name,
StringAppendF(&output, " %d", next_free_number);
} else {
// Range
StringAppendF(&output, " %d-%d", next_free_number, i->first - 1);
StringAppendF(&output, " %d-%d", next_free_number,
i->first - 1);
}
}
next_free_number = i->second;

2
r5dev/thirdparty/protobuf/compiler/command_line_interface.h vendored
View File

@ -49,6 +49,8 @@
#include <vector>
#include <thirdparty/protobuf/stubs/common.h>
// Must be included last.
#include <thirdparty/protobuf/port_def.inc>
namespace google {

55
r5dev/thirdparty/protobuf/compiler/command_line_interface_unittest.cc vendored
View File

@ -50,24 +50,27 @@
#include <thirdparty/protobuf/testing/file.h>
#include <thirdparty/protobuf/testing/file.h>
#include <thirdparty/protobuf/any.pb.h>
#include <thirdparty/protobuf/compiler/mock_code_generator.h>
#include <thirdparty/protobuf/compiler/subprocess.h>
#include <thirdparty/protobuf/compiler/code_generator.h>
#include <thirdparty/protobuf/compiler/command_line_interface.h>
#include <thirdparty/protobuf/test_util2.h>
#include <thirdparty/protobuf/unittest.pb.h>
#include <thirdparty/protobuf/unittest_custom_options.pb.h>
#include <thirdparty/protobuf/io/printer.h>
#include <thirdparty/protobuf/io/zero_copy_stream.h>
#include <thirdparty/protobuf/descriptor.pb.h>
#include <thirdparty/protobuf/descriptor.h>
#include <thirdparty/protobuf/testing/googletest.h>
#include <gtest/gtest.h>
#include <thirdparty/protobuf/stubs/strutil.h>
#include <thirdparty/protobuf/stubs/substitute.h>
#include <thirdparty/protobuf/compiler/code_generator.h>
#include <thirdparty/protobuf/compiler/command_line_interface.h>
#include <thirdparty/protobuf/compiler/mock_code_generator.h>
#include <thirdparty/protobuf/compiler/subprocess.h>
#include <thirdparty/protobuf/descriptor.h>
#include <thirdparty/protobuf/io/io_win32.h>
#include <thirdparty/protobuf/io/printer.h>
#include <thirdparty/protobuf/io/zero_copy_stream.h>
// Must be included last.
#include <thirdparty/protobuf/port_def.inc>
namespace google {
namespace protobuf {
namespace compiler {
@ -96,8 +99,8 @@ bool FileExists(const std::string& path) {
class CommandLineInterfaceTest : public testing::Test {
protected:
virtual void SetUp();
virtual void TearDown();
void SetUp() override;
void TearDown() override;
// Runs the CommandLineInterface with the given command line. The
// command is automatically split on spaces, and the string "$tmpdir"
@ -256,14 +259,14 @@ class CommandLineInterfaceTest : public testing::Test {
class CommandLineInterfaceTest::NullCodeGenerator : public CodeGenerator {
public:
NullCodeGenerator() : called_(false) {}
~NullCodeGenerator() {}
~NullCodeGenerator() override {}
mutable bool called_;
mutable std::string parameter_;
// implements CodeGenerator ----------------------------------------
bool Generate(const FileDescriptor* file, const std::string& parameter,
GeneratorContext* context, std::string* error) const {
GeneratorContext* context, std::string* error) const override {
called_ = true;
parameter_ = parameter;
return true;
@ -1714,7 +1717,7 @@ TEST_F(CommandLineInterfaceTest, WriteDependencyManifestFile) {
" optional Foo foo = 1;\n"
"}\n");
std::string current_working_directory = getcwd(NULL, 0);
std::string current_working_directory = getcwd(nullptr, 0);
SwitchToTempDirectory();
Run("protocol_compiler --dependency_out=manifest --test_out=. "
@ -1753,6 +1756,28 @@ TEST_F(CommandLineInterfaceTest, WriteDependencyManifestFileForAbsolutePath) {
"$tmpdir/bar.proto.MockCodeGenerator.test_generator: "
"$tmpdir/foo.proto\\\n $tmpdir/bar.proto");
}
TEST_F(CommandLineInterfaceTest,
WriteDependencyManifestFileWithDescriptorSetOut) {
CreateTempFile("foo.proto",
"syntax = \"proto2\";\n"
"message Foo {}\n");
CreateTempFile("bar.proto",
"syntax = \"proto2\";\n"
"import \"foo.proto\";\n"
"message Bar {\n"
" optional Foo foo = 1;\n"
"}\n");
Run("protocol_compiler --dependency_out=$tmpdir/manifest "
"--descriptor_set_out=$tmpdir/bar.pb --proto_path=$tmpdir bar.proto");
ExpectNoErrors();
ExpectFileContent("manifest",
"$tmpdir/bar.pb: "
"$tmpdir/foo.proto\\\n $tmpdir/bar.proto");
}
#endif // !_WIN32
TEST_F(CommandLineInterfaceTest, TestArgumentFile) {
@ -2518,12 +2543,12 @@ enum EncodeDecodeTestMode { PROTO_PATH, DESCRIPTOR_SET_IN };
class EncodeDecodeTest : public testing::TestWithParam<EncodeDecodeTestMode> {
protected:
virtual void SetUp() {
void SetUp() override {
WriteUnittestProtoDescriptorSet();
duped_stdin_ = dup(STDIN_FILENO);
}
virtual void TearDown() {
void TearDown() override {
dup2(duped_stdin_, STDIN_FILENO);
close(duped_stdin_);
}
@ -2755,6 +2780,8 @@ INSTANTIATE_TEST_SUITE_P(FileDescriptorSetSource, EncodeDecodeTest,
#endif // !GOOGLE_PROTOBUF_HEAP_CHECK_DRACONIAN
#include <thirdparty/protobuf/port_undef.inc>
} // namespace compiler
} // namespace protobuf
} // namespace google

14
r5dev/thirdparty/protobuf/compiler/cpp/cpp_bootstrap_unittest.cc → r5dev/thirdparty/protobuf/compiler/cpp/bootstrap_unittest.cc vendored
View File

@ -46,8 +46,7 @@
#include <thirdparty/protobuf/testing/file.h>
#include <thirdparty/protobuf/testing/file.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_helpers.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_generator.h>
#include <thirdparty/protobuf/compiler/cpp/generator.h>
#include <thirdparty/protobuf/compiler/importer.h>
#include <thirdparty/protobuf/test_util2.h>
#include <thirdparty/protobuf/io/zero_copy_stream_impl.h>
@ -56,6 +55,7 @@
#include <thirdparty/protobuf/testing/googletest.h>
#include <gtest/gtest.h>
#include <thirdparty/protobuf/stubs/substitute.h>
#include <thirdparty/protobuf/compiler/cpp/helpers.h>
#include <thirdparty/protobuf/stubs/map_util.h>
#include <thirdparty/protobuf/stubs/stl_util.h>
@ -69,13 +69,13 @@ namespace {
class MockErrorCollector : public MultiFileErrorCollector {
public:
MockErrorCollector() {}
~MockErrorCollector() {}
~MockErrorCollector() override {}
std::string text_;
// implements ErrorCollector ---------------------------------------
void AddError(const std::string& filename, int line, int column,
const std::string& message) {
const std::string& message) override {
strings::SubstituteAndAppend(&text_, "$0:$1:$2: $3\n", filename, line, column,
message);
}
@ -113,7 +113,7 @@ class MockGeneratorContext : public GeneratorContext {
// implements GeneratorContext --------------------------------------
virtual io::ZeroCopyOutputStream* Open(const std::string& filename) {
io::ZeroCopyOutputStream* Open(const std::string& filename) override {
auto& map_slot = files_[filename];
map_slot.reset(new std::string);
return new io::StringOutputStream(map_slot.get());
@ -137,9 +137,9 @@ TEST(BootstrapTest, GeneratedFilesMatch) {
// of the data to compare to.
std::map<std::string, std::string> vpath_map;
std::map<std::string, std::string> rpath_map;
rpath_map["third_party/protobuf/src/google/protobuf/test_messages_proto2"] =
rpath_map["third_party/protobuf/test_messages_proto2"] =
"net/proto2/z_generated_example/test_messages_proto2";
rpath_map["third_party/protobuf/src/google/protobuf/test_messages_proto3"] =
rpath_map["third_party/protobuf/test_messages_proto3"] =
"net/proto2/z_generated_example/test_messages_proto3";
rpath_map["net/proto2/internal/proto2_weak"] =
"net/proto2/z_generated_example/proto2_weak";

108
r5dev/thirdparty/protobuf/compiler/cpp/cpp_generator.h vendored
View File

@ -1,106 +1,6 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef GOOGLE_PROTOBUF_COMPILER_CPP_CPP_GENERATOR_H_
#define GOOGLE_PROTOBUF_COMPILER_CPP_CPP_GENERATOR_H_
// Author: kenton@google.com (Kenton Varda)
// Based on original Protocol Buffers design by
// Sanjay Ghemawat, Jeff Dean, and others.
//
// Generates C++ code for a given .proto file.
#include <thirdparty/protobuf/compiler/cpp/generator.h>
#ifndef GOOGLE_PROTOBUF_COMPILER_CPP_GENERATOR_H__
#define GOOGLE_PROTOBUF_COMPILER_CPP_GENERATOR_H__
#include <string>
#include <thirdparty/protobuf/compiler/code_generator.h>
#include <thirdparty/protobuf/port_def.inc>
namespace google {
namespace protobuf {
namespace compiler {
namespace cpp {
// CodeGenerator implementation which generates a C++ source file and
// header. If you create your own protocol compiler binary and you want
// it to support C++ output, you can do so by registering an instance of this
// CodeGenerator with the CommandLineInterface in your main() function.
class PROTOC_EXPORT CppGenerator : public CodeGenerator {
public:
CppGenerator();
~CppGenerator();
enum class Runtime {
kGoogle3, // Use the internal google3 runtime.
kOpensource, // Use the open-source runtime.
// Use the open-source runtime with google3 #include paths. We make these
// absolute to avoid ambiguity, so the runtime will be #included like:
// #include "third_party/protobuf/.../google/protobuf/message.h"
kOpensourceGoogle3
};
void set_opensource_runtime(bool opensource) {
opensource_runtime_ = opensource;
}
// If set to a non-empty string, generated code will do:
// #include "<BASE>/google/protobuf/message.h"
// instead of:
// #include <thirdparty/protobuf/message.h>
// This has no effect if opensource_runtime = false.
void set_runtime_include_base(const std::string& base) {
runtime_include_base_ = base;
}
// implements CodeGenerator ----------------------------------------
bool Generate(const FileDescriptor* file, const std::string& parameter,
GeneratorContext* generator_context,
std::string* error) const override;
uint64_t GetSupportedFeatures() const override {
// We don't fully support this yet, but this is needed to unblock the tests,
// and we will have full support before the experimental flag is removed.
return FEATURE_PROTO3_OPTIONAL;
}
private:
bool opensource_runtime_ = true;
std::string runtime_include_base_;
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CppGenerator);
};
} // namespace cpp
} // namespace compiler
} // namespace protobuf
} // namespace google
#include <thirdparty/protobuf/port_undef.inc>
#endif // GOOGLE_PROTOBUF_COMPILER_CPP_GENERATOR_H__
#endif // GOOGLE_PROTOBUF_COMPILER_CPP_CPP_GENERATOR_H_

1303
r5dev/thirdparty/protobuf/compiler/cpp/cpp_parse_function_generator.cc vendored
View File

File diff suppressed because it is too large Load Diff

10
r5dev/thirdparty/protobuf/compiler/cpp/cpp_enum.cc → r5dev/thirdparty/protobuf/compiler/cpp/enum.cc vendored
View File

@ -32,16 +32,16 @@
// Based on original Protocol Buffers design by
// Sanjay Ghemawat, Jeff Dean, and others.
#include <thirdparty/protobuf/compiler/cpp/cpp_enum.h>
#include <thirdparty/protobuf/compiler/cpp/enum.h>
#include <cstdint>
#include <limits>
#include <map>
#include <thirdparty/protobuf/compiler/cpp/cpp_helpers.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_names.h>
#include <thirdparty/protobuf/io/printer.h>
#include <thirdparty/protobuf/stubs/strutil.h>
#include <thirdparty/protobuf/compiler/cpp/helpers.h>
#include <thirdparty/protobuf/compiler/cpp/names.h>
namespace google {
namespace protobuf {
@ -88,7 +88,7 @@ EnumGenerator::EnumGenerator(const EnumDescriptor* descriptor,
variables_["nested_name"] = descriptor_->name();
variables_["resolved_name"] = ResolveKeyword(descriptor_->name());
variables_["prefix"] =
(descriptor_->containing_type() == NULL) ? "" : classname_ + "_";
(descriptor_->containing_type() == nullptr) ? "" : classname_ + "_";
}
EnumGenerator::~EnumGenerator() {}
@ -405,7 +405,7 @@ void EnumGenerator::GenerateMethods(int idx, io::Printer* printer) {
descriptor_->value_count());
}
if (descriptor_->containing_type() != NULL) {
if (descriptor_->containing_type() != nullptr) {
std::string parent = ClassName(descriptor_->containing_type(), false);
// Before C++17, we must define the static constants which were
// declared in the header, to give the linker a place to put them.

3
r5dev/thirdparty/protobuf/compiler/cpp/cpp_enum.h → r5dev/thirdparty/protobuf/compiler/cpp/enum.h vendored
View File

@ -38,8 +38,9 @@
#include <map>
#include <set>
#include <string>
#include <thirdparty/protobuf/compiler/cpp/cpp_options.h>
#include <thirdparty/protobuf/descriptor.h>
#include <thirdparty/protobuf/compiler/cpp/options.h>
namespace google {
namespace protobuf {

131
r5dev/thirdparty/protobuf/compiler/cpp/cpp_enum_field.cc → r5dev/thirdparty/protobuf/compiler/cpp/enum_field.cc vendored
View File

@ -32,11 +32,13 @@
// Based on original Protocol Buffers design by
// Sanjay Ghemawat, Jeff Dean, and others.
#include <thirdparty/protobuf/compiler/cpp/cpp_enum_field.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_helpers.h>
#include <thirdparty/protobuf/compiler/cpp/enum_field.h>
#include <thirdparty/protobuf/io/printer.h>
#include <thirdparty/protobuf/wire_format.h>
#include <thirdparty/protobuf/stubs/strutil.h>
#include <thirdparty/protobuf/compiler/cpp/field.h>
#include <thirdparty/protobuf/compiler/cpp/helpers.h>
namespace google {
namespace protobuf {
@ -53,6 +55,10 @@ void SetEnumVariables(const FieldDescriptor* descriptor,
(*variables)["type"] = QualifiedClassName(descriptor->enum_type(), options);
(*variables)["default"] = Int32ToString(default_value->number());
(*variables)["full_name"] = descriptor->full_name();
(*variables)["cached_byte_size_name"] = MakeVarintCachedSizeName(descriptor);
bool cold = ShouldSplit(descriptor, options);
(*variables)["cached_byte_size_field"] =
MakeVarintCachedSizeFieldName(descriptor, cold);
}
} // namespace
@ -90,7 +96,7 @@ void EnumFieldGenerator::GenerateInlineAccessorDefinitions(
Formatter format(printer, variables_);
format(
"inline $type$ $classname$::_internal_$name$() const {\n"
" return static_cast< $type$ >($name$_);\n"
" return static_cast< $type$ >($field$);\n"
"}\n"
"inline $type$ $classname$::$name$() const {\n"
"$annotate_get$"
@ -103,9 +109,10 @@ void EnumFieldGenerator::GenerateInlineAccessorDefinitions(
}
format(
" $set_hasbit$\n"
" $name$_ = value;\n"
" $field$ = value;\n"
"}\n"
"inline void $classname$::set_$name$($type$ value) {\n"
"$maybe_prepare_split_message$"
" _internal_set_$name$(value);\n"
"$annotate_set$"
" // @@protoc_insertion_point(field_set:$full_name$)\n"
@ -114,28 +121,23 @@ void EnumFieldGenerator::GenerateInlineAccessorDefinitions(
void EnumFieldGenerator::GenerateClearingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_ = $default$;\n");
format("$field$ = $default$;\n");
}
void EnumFieldGenerator::GenerateMergingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
format("_internal_set_$name$(from._internal_$name$());\n");
format("_this->_internal_set_$name$(from._internal_$name$());\n");
}
void EnumFieldGenerator::GenerateSwappingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
format("swap($name$_, other->$name$_);\n");
}
void EnumFieldGenerator::GenerateConstructorCode(io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_ = $default$;\n");
format("swap($field$, other->$field$);\n");
}
void EnumFieldGenerator::GenerateCopyConstructorCode(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_ = from.$name$_;\n");
format("_this->$field$ = from.$field$;\n");
}
void EnumFieldGenerator::GenerateSerializeWithCachedSizesToArray(
@ -143,7 +145,7 @@ void EnumFieldGenerator::GenerateSerializeWithCachedSizesToArray(
Formatter format(printer, variables_);
format(
"target = stream->EnsureSpace(target);\n"
"target = ::$proto_ns$::internal::WireFormatLite::WriteEnumToArray(\n"
"target = ::_pbi::WireFormatLite::WriteEnumToArray(\n"
" $number$, this->_internal_$name$(), target);\n");
}
@ -151,15 +153,29 @@ void EnumFieldGenerator::GenerateByteSize(io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"total_size += $tag_size$ +\n"
" "
"::$proto_ns$::internal::WireFormatLite::EnumSize(this->_internal_$name$("
"));\n");
" ::_pbi::WireFormatLite::EnumSize(this->_internal_$name$());\n");
}
void EnumFieldGenerator::GenerateConstinitInitializer(
void EnumFieldGenerator::GenerateConstexprAggregateInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_($default$)\n");
format("/*decltype($field$)*/$default$");
}
void EnumFieldGenerator::GenerateAggregateInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
if (ShouldSplit(descriptor_, options_)) {
format("decltype(Impl_::Split::$name$_){$default$}");
return;
}
format("decltype($field$){$default$}");
}
void EnumFieldGenerator::GenerateCopyAggregateInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("decltype($field$){}");
}
// ===================================================================
@ -178,7 +194,7 @@ void EnumOneofFieldGenerator::GenerateInlineAccessorDefinitions(
format(
"inline $type$ $classname$::_internal_$name$() const {\n"
" if (_internal_has_$name$()) {\n"
" return static_cast< $type$ >($field_member$);\n"
" return static_cast< $type$ >($field$);\n"
" }\n"
" return static_cast< $type$ >($default$);\n"
"}\n"
@ -196,7 +212,7 @@ void EnumOneofFieldGenerator::GenerateInlineAccessorDefinitions(
" clear_$oneof_name$();\n"
" set_has_$name$();\n"
" }\n"
" $field_member$ = value;\n"
" $field$ = value;\n"
"}\n"
"inline void $classname$::set_$name$($type$ value) {\n"
" _internal_set_$name$(value);\n"
@ -207,7 +223,7 @@ void EnumOneofFieldGenerator::GenerateInlineAccessorDefinitions(
void EnumOneofFieldGenerator::GenerateClearingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
format("$field_member$ = $default$;\n");
format("$field$ = $default$;\n");
}
void EnumOneofFieldGenerator::GenerateSwappingCode(io::Printer* printer) const {
@ -217,7 +233,7 @@ void EnumOneofFieldGenerator::GenerateSwappingCode(io::Printer* printer) const {
void EnumOneofFieldGenerator::GenerateConstructorCode(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("$ns$::_$classname$_default_instance_.$name$_ = $default$;\n");
format("$ns$::_$classname$_default_instance_.$field$ = $default$;\n");
}
// ===================================================================
@ -236,7 +252,7 @@ void RepeatedEnumFieldGenerator::GeneratePrivateMembers(
format("::$proto_ns$::RepeatedField<int> $name$_;\n");
if (descriptor_->is_packed() &&
HasGeneratedMethods(descriptor_->file(), options_)) {
format("mutable std::atomic<int> _$name$_cached_byte_size_;\n");
format("mutable std::atomic<int> $cached_byte_size_name$;\n");
}
}
@ -265,7 +281,7 @@ void RepeatedEnumFieldGenerator::GenerateInlineAccessorDefinitions(
Formatter format(printer, variables_);
format(
"inline $type$ $classname$::_internal_$name$(int index) const {\n"
" return static_cast< $type$ >($name$_.Get(index));\n"
" return static_cast< $type$ >($field$.Get(index));\n"
"}\n"
"inline $type$ $classname$::$name$(int index) const {\n"
"$annotate_get$"
@ -277,7 +293,7 @@ void RepeatedEnumFieldGenerator::GenerateInlineAccessorDefinitions(
format(" assert($type$_IsValid(value));\n");
}
format(
" $name$_.Set(index, value);\n"
" $field$.Set(index, value);\n"
"$annotate_set$"
" // @@protoc_insertion_point(field_set:$full_name$)\n"
"}\n"
@ -286,7 +302,7 @@ void RepeatedEnumFieldGenerator::GenerateInlineAccessorDefinitions(
format(" assert($type$_IsValid(value));\n");
}
format(
" $name$_.Add(value);\n"
" $field$.Add(value);\n"
"}\n"
"inline void $classname$::add_$name$($type$ value) {\n"
" _internal_add_$name$(value);\n"
@ -297,11 +313,11 @@ void RepeatedEnumFieldGenerator::GenerateInlineAccessorDefinitions(
"$classname$::$name$() const {\n"
"$annotate_list$"
" // @@protoc_insertion_point(field_list:$full_name$)\n"
" return $name$_;\n"
" return $field$;\n"
"}\n"
"inline ::$proto_ns$::RepeatedField<int>*\n"
"$classname$::_internal_mutable_$name$() {\n"
" return &$name$_;\n"
" return &$field$;\n"
"}\n"
"inline ::$proto_ns$::RepeatedField<int>*\n"
"$classname$::mutable_$name$() {\n"
@ -314,19 +330,19 @@ void RepeatedEnumFieldGenerator::GenerateInlineAccessorDefinitions(
void RepeatedEnumFieldGenerator::GenerateClearingCode(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_.Clear();\n");
format("$field$.Clear();\n");
}
void RepeatedEnumFieldGenerator::GenerateMergingCode(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_.MergeFrom(from.$name$_);\n");
format("_this->$field$.MergeFrom(from.$field$);\n");
}
void RepeatedEnumFieldGenerator::GenerateSwappingCode(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_.InternalSwap(&other->$name$_);\n");
format("$field$.InternalSwap(&other->$field$);\n");
}
void RepeatedEnumFieldGenerator::GenerateConstructorCode(
@ -334,6 +350,12 @@ void RepeatedEnumFieldGenerator::GenerateConstructorCode(
// Not needed for repeated fields.
}
void RepeatedEnumFieldGenerator::GenerateDestructorCode(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("$field$.~RepeatedField();\n");
}
void RepeatedEnumFieldGenerator::GenerateSerializeWithCachedSizesToArray(
io::Printer* printer) const {
Formatter format(printer, variables_);
@ -342,17 +364,17 @@ void RepeatedEnumFieldGenerator::GenerateSerializeWithCachedSizesToArray(
format(
"{\n"
" int byte_size = "
"_$name$_cached_byte_size_.load(std::memory_order_relaxed);\n"
"$cached_byte_size_field$.load(std::memory_order_relaxed);\n"
" if (byte_size > 0) {\n"
" target = stream->WriteEnumPacked(\n"
" $number$, $name$_, byte_size, target);\n"
" $number$, $field$, byte_size, target);\n"
" }\n"
"}\n");
} else {
format(
"for (int i = 0, n = this->_internal_$name$_size(); i < n; i++) {\n"
" target = stream->EnsureSpace(target);\n"
" target = ::$proto_ns$::internal::WireFormatLite::WriteEnumToArray(\n"
" target = ::_pbi::WireFormatLite::WriteEnumToArray(\n"
" $number$, this->_internal_$name$(i), target);\n"
"}\n");
}
@ -368,7 +390,7 @@ void RepeatedEnumFieldGenerator::GenerateByteSize(io::Printer* printer) const {
format.Indent();
format(
"for (unsigned int i = 0; i < count; i++) {\n"
" data_size += ::$proto_ns$::internal::WireFormatLite::EnumSize(\n"
" data_size += ::_pbi::WireFormatLite::EnumSize(\n"
" this->_internal_$name$(static_cast<int>(i)));\n"
"}\n");
@ -376,11 +398,11 @@ void RepeatedEnumFieldGenerator::GenerateByteSize(io::Printer* printer) const {
format(
"if (data_size > 0) {\n"
" total_size += $tag_size$ +\n"
" ::$proto_ns$::internal::WireFormatLite::Int32Size(\n"
" static_cast<$int32$>(data_size));\n"
" "
"::_pbi::WireFormatLite::Int32Size(static_cast<$int32$>(data_size));\n"
"}\n"
"int cached_size = ::$proto_ns$::internal::ToCachedSize(data_size);\n"
"_$name$_cached_byte_size_.store(cached_size,\n"
"int cached_size = ::_pbi::ToCachedSize(data_size);\n"
"$cached_byte_size_field$.store(cached_size,\n"
" std::memory_order_relaxed);\n"
"total_size += data_size;\n");
} else {
@ -390,13 +412,36 @@ void RepeatedEnumFieldGenerator::GenerateByteSize(io::Printer* printer) const {
format("}\n");
}
void RepeatedEnumFieldGenerator::GenerateConstinitInitializer(
void RepeatedEnumFieldGenerator::GenerateConstexprAggregateInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_()");
format("/*decltype($field$)*/{}");
if (descriptor_->is_packed() &&
HasGeneratedMethods(descriptor_->file(), options_)) {
format("\n, _$name$_cached_byte_size_(0)");
format("\n, /*decltype($cached_byte_size_field$)*/{0}");
}
}
void RepeatedEnumFieldGenerator::GenerateAggregateInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("decltype($field$){arena}");
if (descriptor_->is_packed() &&
HasGeneratedMethods(descriptor_->file(), options_)) {
// std::atomic has no copy constructor, which prevents explicit aggregate
// initialization pre-C++17.
format("\n, /*decltype($cached_byte_size_field$)*/{0}");
}
}
void RepeatedEnumFieldGenerator::GenerateCopyAggregateInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("decltype($field$){from.$field$}");
if (descriptor_->is_packed() &&
HasGeneratedMethods(descriptor_->file(), options_)) {
// std::atomic has no copy constructor.
format("\n, /*decltype($cached_byte_size_field$)*/{0}");
}
}

26
r5dev/thirdparty/protobuf/compiler/cpp/cpp_enum_field.h → r5dev/thirdparty/protobuf/compiler/cpp/enum_field.h vendored
View File

@ -37,7 +37,8 @@
#include <map>
#include <string>
#include <thirdparty/protobuf/compiler/cpp/cpp_field.h>
#include <thirdparty/protobuf/compiler/cpp/field.h>
namespace google {
namespace protobuf {
@ -47,7 +48,7 @@ namespace cpp {
class EnumFieldGenerator : public FieldGenerator {
public:
EnumFieldGenerator(const FieldDescriptor* descriptor, const Options& options);
~EnumFieldGenerator();
~EnumFieldGenerator() override;
// implements FieldGenerator ---------------------------------------
void GeneratePrivateMembers(io::Printer* printer) const override;
@ -56,12 +57,15 @@ class EnumFieldGenerator : public FieldGenerator {
void GenerateClearingCode(io::Printer* printer) const override;
void GenerateMergingCode(io::Printer* printer) const override;
void GenerateSwappingCode(io::Printer* printer) const override;
void GenerateConstructorCode(io::Printer* printer) const override;
void GenerateConstructorCode(io::Printer* printer) const override {}
void GenerateCopyConstructorCode(io::Printer* printer) const override;
void GenerateSerializeWithCachedSizesToArray(
io::Printer* printer) const override;
void GenerateByteSize(io::Printer* printer) const override;
void GenerateConstinitInitializer(io::Printer* printer) const override;
void GenerateConstexprAggregateInitializer(
io::Printer* printer) const override;
void GenerateAggregateInitializer(io::Printer* printer) const override;
void GenerateCopyAggregateInitializer(io::Printer* printer) const override;
private:
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(EnumFieldGenerator);
@ -71,7 +75,7 @@ class EnumOneofFieldGenerator : public EnumFieldGenerator {
public:
EnumOneofFieldGenerator(const FieldDescriptor* descriptor,
const Options& options);
~EnumOneofFieldGenerator();
~EnumOneofFieldGenerator() override;
// implements FieldGenerator ---------------------------------------
void GenerateInlineAccessorDefinitions(io::Printer* printer) const override;
@ -87,7 +91,7 @@ class RepeatedEnumFieldGenerator : public FieldGenerator {
public:
RepeatedEnumFieldGenerator(const FieldDescriptor* descriptor,
const Options& options);
~RepeatedEnumFieldGenerator();
~RepeatedEnumFieldGenerator() override;
// implements FieldGenerator ---------------------------------------
void GeneratePrivateMembers(io::Printer* printer) const override;
@ -97,11 +101,17 @@ class RepeatedEnumFieldGenerator : public FieldGenerator {
void GenerateMergingCode(io::Printer* printer) const override;
void GenerateSwappingCode(io::Printer* printer) const override;
void GenerateConstructorCode(io::Printer* printer) const override;
void GenerateCopyConstructorCode(io::Printer* printer) const override {}
void GenerateCopyConstructorCode(io::Printer* /*printer*/) const override {
GOOGLE_CHECK(!ShouldSplit(descriptor_, options_));
}
void GenerateDestructorCode(io::Printer* printer) const override;
void GenerateSerializeWithCachedSizesToArray(
io::Printer* printer) const override;
void GenerateByteSize(io::Printer* printer) const override;
void GenerateConstinitInitializer(io::Printer* printer) const override;
void GenerateConstexprAggregateInitializer(
io::Printer* printer) const override;
void GenerateAggregateInitializer(io::Printer* printer) const override;
void GenerateCopyAggregateInitializer(io::Printer* printer) const override;
private:
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(RepeatedEnumFieldGenerator);

40
r5dev/thirdparty/protobuf/compiler/cpp/cpp_extension.cc → r5dev/thirdparty/protobuf/compiler/cpp/extension.cc vendored
View File

@ -32,12 +32,14 @@
// Based on original Protocol Buffers design by
// Sanjay Ghemawat, Jeff Dean, and others.
#include <thirdparty/protobuf/compiler/cpp/cpp_extension.h>
#include <thirdparty/protobuf/compiler/cpp/extension.h>
#include <map>
#include <thirdparty/protobuf/compiler/cpp/cpp_helpers.h>
#include <thirdparty/protobuf/descriptor.pb.h>
#include <thirdparty/protobuf/io/printer.h>
#include <thirdparty/protobuf/stubs/strutil.h>
#include <thirdparty/protobuf/compiler/cpp/helpers.h>
#include <thirdparty/protobuf/descriptor.pb.h>
namespace google {
namespace protobuf {
@ -76,6 +78,7 @@ ExtensionGenerator::ExtensionGenerator(const FieldDescriptor* descriptor,
break;
}
SetCommonVars(options, &variables_);
SetCommonMessageDataVariables(descriptor_->containing_type(), &variables_);
variables_["extendee"] =
QualifiedClassName(descriptor_->containing_type(), options_);
variables_["type_traits"] = type_traits_;
@ -91,6 +94,19 @@ ExtensionGenerator::ExtensionGenerator(const FieldDescriptor* descriptor,
variables_["scope"] = scope;
variables_["scoped_name"] = ExtensionName(descriptor_);
variables_["number"] = StrCat(descriptor_->number());
bool add_verify_fn =
// Only verify msgs.
descriptor_->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
// Options say to verify.
ShouldVerify(descriptor_->message_type(), options_, scc_analyzer_) &&
ShouldVerify(descriptor_->containing_type(), options_, scc_analyzer_);
variables_["verify_fn"] =
add_verify_fn
? StrCat("&", FieldMessageTypeName(descriptor_, options_),
"::InternalVerify")
: "nullptr";
}
ExtensionGenerator::~ExtensionGenerator() {}
@ -164,23 +180,11 @@ void ExtensionGenerator::GenerateDefinition(io::Printer* printer) {
}
format(
"PROTOBUF_ATTRIBUTE_INIT_PRIORITY "
"PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 "
"::$proto_ns$::internal::ExtensionIdentifier< $extendee$,\n"
" ::$proto_ns$::internal::$type_traits$, $field_type$, $packed$ >\n"
" $scoped_name$($constant_name$, $1$);\n",
" ::$proto_ns$::internal::$type_traits$, $field_type$, $packed$>\n"
" $scoped_name$($constant_name$, $1$, $verify_fn$);\n",
default_str);
// Register extension verify function if needed.
if (descriptor_->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
ShouldVerify(descriptor_->message_type(), options_, scc_analyzer_) &&
ShouldVerify(descriptor_->containing_type(), options_, scc_analyzer_)) {
format(
"PROTOBUF_ATTRIBUTE_INIT_PRIORITY "
"::$proto_ns$::internal::RegisterExtensionVerify< $extendee$,\n"
" $1$, $number$> $2$_$name$_register;\n",
ClassName(descriptor_->message_type(), true),
IsScoped() ? ClassName(descriptor_->extension_scope(), false) : "");
}
}
} // namespace cpp

2
r5dev/thirdparty/protobuf/compiler/cpp/cpp_extension.h → r5dev/thirdparty/protobuf/compiler/cpp/extension.h vendored
View File

@ -39,7 +39,7 @@
#include <string>
#include <thirdparty/protobuf/stubs/common.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_options.h>
#include <thirdparty/protobuf/compiler/cpp/options.h>
namespace google {
namespace protobuf {

92
r5dev/thirdparty/protobuf/compiler/cpp/cpp_field.cc → r5dev/thirdparty/protobuf/compiler/cpp/field.cc vendored
View File

@ -32,25 +32,25 @@
// Based on original Protocol Buffers design by
// Sanjay Ghemawat, Jeff Dean, and others.
#include <thirdparty/protobuf/compiler/cpp/cpp_field.h>
#include <thirdparty/protobuf/compiler/cpp/field.h>
#include <cstdint>
#include <memory>
#include <string>
#include <thirdparty/protobuf/compiler/cpp/cpp_helpers.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_primitive_field.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_string_field.h>
#include <thirdparty/protobuf/stubs/strutil.h>
#include <thirdparty/protobuf/stubs/substitute.h>
#include <thirdparty/protobuf/compiler/cpp/helpers.h>
#include <thirdparty/protobuf/compiler/cpp/primitive_field.h>
#include <thirdparty/protobuf/compiler/cpp/string_field.h>
#include <thirdparty/protobuf/stubs/logging.h>
#include <thirdparty/protobuf/stubs/common.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_enum_field.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_map_field.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_message_field.h>
#include <thirdparty/protobuf/descriptor.pb.h>
#include <thirdparty/protobuf/io/printer.h>
#include <thirdparty/protobuf/wire_format.h>
#include <thirdparty/protobuf/compiler/cpp/enum_field.h>
#include <thirdparty/protobuf/compiler/cpp/map_field.h>
#include <thirdparty/protobuf/compiler/cpp/message_field.h>
#include <thirdparty/protobuf/descriptor.pb.h>
namespace google {
namespace protobuf {
@ -81,7 +81,7 @@ std::string GenerateTemplateForOneofString(const FieldDescriptor* descriptor,
std::string field_name = google::protobuf::compiler::cpp::FieldName(descriptor);
std::string field_pointer =
descriptor->options().ctype() == google::protobuf::FieldOptions::STRING
? "$0.GetPointer()"
? "$0.UnsafeGetPointer()"
: "$0";
if (descriptor->default_value_string().empty()) {
@ -103,7 +103,7 @@ std::string GenerateTemplateForOneofString(const FieldDescriptor* descriptor,
return strings::Substitute(
StrCat("_internal_has_", field_name, "() ? ", field_pointer, " : ",
default_value_pointer),
field_member, MakeDefaultName(descriptor));
field_member, MakeDefaultFieldName(descriptor));
}
std::string GenerateTemplateForSingleString(const FieldDescriptor* descriptor,
@ -114,8 +114,8 @@ std::string GenerateTemplateForSingleString(const FieldDescriptor* descriptor,
if (descriptor->options().ctype() == google::protobuf::FieldOptions::STRING) {
return strings::Substitute(
"$0.IsDefault(nullptr) ? &$1.get() : $0.GetPointer()", field_member,
MakeDefaultName(descriptor));
"$0.IsDefault() ? &$1.get() : $0.UnsafeGetPointer()", field_member,
MakeDefaultFieldName(descriptor));
}
return StrCat("&", field_member);
@ -150,14 +150,12 @@ void AddAccessorAnnotations(const FieldDescriptor* descriptor,
google::protobuf::FileOptions::LITE_RUNTIME) {
return;
}
std::string field_member = (*variables)["field_member"];
std::string field_member = (*variables)["field"];
const google::protobuf::OneofDescriptor* oneof_member =
descriptor->real_containing_oneof();
if (oneof_member) {
field_member = StrCat(oneof_member->name(), "_.", field_member);
}
const std::string proto_ns = (*variables)["proto_ns"];
const std::string substitute_template_prefix = " _tracker_.$1<$0>(this, ";
const std::string substitute_template_prefix =
StrCat(" ", (*variables)["tracker"], ".$1<$0>(this, ");
std::string prepared_template;
// Flat template is needed if the prepared one is introspecting the values
@ -178,7 +176,7 @@ void AddAccessorAnnotations(const FieldDescriptor* descriptor,
} else if (descriptor->is_map()) {
prepared_template = "nullptr";
} else if (descriptor->type() == FieldDescriptor::TYPE_MESSAGE &&
!descriptor->options().lazy()) {
!IsExplicitLazy(descriptor)) {
prepared_template = "nullptr";
} else if (descriptor->cpp_type() == FieldDescriptor::CPPTYPE_STRING) {
if (oneof_member) {
@ -238,13 +236,16 @@ void SetCommonFieldVariables(const FieldDescriptor* descriptor,
std::map<std::string, std::string>* variables,
const Options& options) {
SetCommonVars(options, variables);
SetCommonMessageDataVariables(descriptor->containing_type(), variables);
(*variables)["ns"] = Namespace(descriptor, options);
(*variables)["name"] = FieldName(descriptor);
(*variables)["index"] = StrCat(descriptor->index());
(*variables)["number"] = StrCat(descriptor->number());
(*variables)["classname"] = ClassName(FieldScope(descriptor), false);
(*variables)["declared_type"] = DeclaredTypeMethodName(descriptor->type());
(*variables)["field_member"] = FieldName(descriptor) + "_";
bool split = ShouldSplit(descriptor, options);
(*variables)["field"] = FieldMemberName(descriptor, split);
(*variables)["tag_size"] = StrCat(
WireFormat::TagSize(descriptor->number(), descriptor->type()));
@ -252,12 +253,8 @@ void SetCommonFieldVariables(const FieldDescriptor* descriptor,
(*variables)["set_hasbit"] = "";
(*variables)["clear_hasbit"] = "";
if (HasHasbit(descriptor)) {
(*variables)["set_hasbit_io"] =
"_Internal::set_has_" + FieldName(descriptor) + "(&_has_bits_);";
} else {
(*variables)["set_hasbit_io"] = "";
}
(*variables)["maybe_prepare_split_message"] =
split ? " PrepareSplitMessageForWrite();\n" : "";
AddAccessorAnnotations(descriptor, options, variables);
@ -275,10 +272,10 @@ void FieldGenerator::SetHasBitIndex(int32_t has_bit_index) {
return;
}
variables_["set_hasbit"] = StrCat(
"_has_bits_[", has_bit_index / 32, "] |= 0x",
variables_["has_bits"], "[", has_bit_index / 32, "] |= 0x",
strings::Hex(1u << (has_bit_index % 32), strings::ZERO_PAD_8), "u;");
variables_["clear_hasbit"] = StrCat(
"_has_bits_[", has_bit_index / 32, "] &= ~0x",
variables_["has_bits"], "[", has_bit_index / 32, "] &= ~0x",
strings::Hex(1u << (has_bit_index % 32), strings::ZERO_PAD_8), "u;");
}
@ -287,24 +284,57 @@ void FieldGenerator::SetInlinedStringIndex(int32_t inlined_string_index) {
GOOGLE_CHECK_EQ(inlined_string_index, -1);
return;
}
// The first bit is the tracking bit for on demand registering ArenaDtor.
GOOGLE_CHECK_GT(inlined_string_index, 0)
<< "_inlined_string_donated_'s bit 0 is reserved for arena dtor tracking";
variables_["inlined_string_donated"] = StrCat(
"(_inlined_string_donated_[", inlined_string_index / 32, "] & 0x",
"(", variables_["inlined_string_donated_array"], "[",
inlined_string_index / 32, "] & 0x",
strings::Hex(1u << (inlined_string_index % 32), strings::ZERO_PAD_8),
"u) != 0;");
variables_["donating_states_word"] =
StrCat("_inlined_string_donated_[", inlined_string_index / 32, "]");
StrCat(variables_["inlined_string_donated_array"], "[",
inlined_string_index / 32, "]");
variables_["mask_for_undonate"] = StrCat(
"~0x", strings::Hex(1u << (inlined_string_index % 32), strings::ZERO_PAD_8),
"u");
}
void FieldGenerator::GenerateAggregateInitializer(io::Printer* printer) const {
Formatter format(printer, variables_);
if (ShouldSplit(descriptor_, options_)) {
format("decltype(Impl_::Split::$name$_){arena}");
return;
}
format("decltype($field$){arena}");
}
void FieldGenerator::GenerateConstexprAggregateInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("/*decltype($field$)*/{}");
}
void FieldGenerator::GenerateCopyAggregateInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("decltype($field$){from.$field$}");
}
void FieldGenerator::GenerateCopyConstructorCode(io::Printer* printer) const {
if (ShouldSplit(descriptor_, options_)) {
// There is no copy constructor for the `Split` struct, so we need to copy
// the value here.
Formatter format(printer, variables_);
format("$field$ = from.$field$;\n");
}
}
void SetCommonOneofFieldVariables(
const FieldDescriptor* descriptor,
std::map<std::string, std::string>* variables) {
const std::string prefix = descriptor->containing_oneof()->name() + "_.";
(*variables)["oneof_name"] = descriptor->containing_oneof()->name();
(*variables)["field_member"] =
StrCat(prefix, (*variables)["name"], "_");
}
FieldGenerator::~FieldGenerator() {}

52
r5dev/thirdparty/protobuf/compiler/cpp/cpp_field.h → r5dev/thirdparty/protobuf/compiler/cpp/field.h vendored
View File

@ -40,9 +40,9 @@
#include <memory>
#include <string>
#include <thirdparty/protobuf/compiler/cpp/cpp_helpers.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_options.h>
#include <thirdparty/protobuf/descriptor.h>
#include <thirdparty/protobuf/compiler/cpp/helpers.h>
#include <thirdparty/protobuf/compiler/cpp/options.h>
namespace google {
namespace protobuf {
@ -136,7 +136,7 @@ class FieldGenerator {
virtual void GenerateMergingCode(io::Printer* printer) const = 0;
// Generates a copy constructor
virtual void GenerateCopyConstructorCode(io::Printer* printer) const = 0;
virtual void GenerateCopyConstructorCode(io::Printer* printer) const;
// Generate lines of code (statements, not declarations) which swaps
// this field and the corresponding field of another message, which
@ -150,6 +150,9 @@ class FieldGenerator {
// method, invoked by each of the generated constructors.
virtual void GenerateConstructorCode(io::Printer* printer) const = 0;
// Generate initialization code for private members in the cold struct.
virtual void GenerateCreateSplitMessageCode(io::Printer* printer) const {}
// Generate any code that needs to go in the class's SharedDtor() method,
// invoked by the destructor.
// Most field types don't need this, so the default implementation is empty.
@ -158,18 +161,39 @@ class FieldGenerator {
// Generate a manual destructor invocation for use when the message is on an
// arena. The code that this method generates will be executed inside a
// shared-for-the-whole-message-class method registered with
// OwnDestructor(). The method should return |true| if it generated any code
// that requires a call; this allows the message generator to eliminate the
// OwnDestructor() registration if no fields require it.
virtual bool GenerateArenaDestructorCode(io::Printer* printer) const {
return false;
// OwnDestructor().
virtual void GenerateArenaDestructorCode(io::Printer* printer) const {
GOOGLE_CHECK(NeedsArenaDestructor() == ArenaDtorNeeds::kNone)
<< descriptor_->cpp_type_name();
}
// Generate initialization code for private members declared by
// GeneratePrivateMembers(), specifically for the constexpr constructor.
// These go into the constructor's initializer list and must follow that
// syntax (eg `field_(args)`). Does not include `:` or `,` separators.
virtual void GenerateConstinitInitializer(io::Printer* printer) const {}
// GeneratePrivateMembers(). These go into the SharedCtor's
// aggregate initialization of the _impl_ struct and must follow the syntax
// (e.g. `decltype($field$){$default$}`). Does not include `:` or `,`
// separators. Default values should be specified here when possible.
//
// Note: We use `decltype($field$)` for both explicit construction and the
// fact that it's self-documenting. Pre-C++17, copy elision isn't guaranteed
// in aggregate initialization so a valid copy/move constructor must exist
// (even though it's not used). Because of this, we need to comment out the
// decltype and fallback to implicit construction.
virtual void GenerateAggregateInitializer(io::Printer* printer) const;
// Generate constinit initialization code for private members declared by
// GeneratePrivateMembers(). These go into the constexpr constructor's
// aggregate initialization of the _impl_ struct and must follow the syntax
// (e.g. `/*decltype($field$)*/{}`, see above). Does not
// include `:` or `,` separators.
virtual void GenerateConstexprAggregateInitializer(
io::Printer* printer) const;
// Generate copy initialization code for private members declared by
// GeneratePrivateMembers(). These go into the copy constructor's
// aggregate initialization of the _impl_ struct and must follow the syntax
// (e.g. `decltype($field$){from.$field$}`, see above). Does not
// include `:` or `,` separators.
virtual void GenerateCopyAggregateInitializer(io::Printer* printer) const;
// Generate lines to serialize this field directly to the array "target",
// which are placed within the message's SerializeWithCachedSizesToArray()
@ -187,6 +211,10 @@ class FieldGenerator {
virtual bool IsInlined() const { return false; }
virtual ArenaDtorNeeds NeedsArenaDestructor() const {
return ArenaDtorNeeds::kNone;
}
void SetHasBitIndex(int32_t has_bit_index);
void SetInlinedStringIndex(int32_t inlined_string_index);

351
r5dev/thirdparty/protobuf/compiler/cpp/cpp_file.cc → r5dev/thirdparty/protobuf/compiler/cpp/file.cc vendored
View File

@ -32,7 +32,7 @@
// Based on original Protocol Buffers design by
// Sanjay Ghemawat, Jeff Dean, and others.
#include <thirdparty/protobuf/compiler/cpp/cpp_file.h>
#include <thirdparty/protobuf/compiler/cpp/file.h>
#include <iostream>
#include <map>
@ -42,16 +42,16 @@
#include <unordered_set>
#include <vector>
#include <thirdparty/protobuf/compiler/cpp/cpp_enum.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_extension.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_field.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_helpers.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_message.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_service.h>
#include <thirdparty/protobuf/compiler/scc.h>
#include <thirdparty/protobuf/descriptor.pb.h>
#include <thirdparty/protobuf/io/printer.h>
#include <thirdparty/protobuf/stubs/strutil.h>
#include <thirdparty/protobuf/compiler/cpp/enum.h>
#include <thirdparty/protobuf/compiler/cpp/extension.h>
#include <thirdparty/protobuf/compiler/cpp/field.h>
#include <thirdparty/protobuf/compiler/cpp/helpers.h>
#include <thirdparty/protobuf/compiler/cpp/message.h>
#include <thirdparty/protobuf/compiler/cpp/service.h>
#include <thirdparty/protobuf/descriptor.pb.h>
// Must be last.
#include <thirdparty/protobuf/port_def.inc>
@ -87,6 +87,23 @@ std::vector<const T*> Sorted(const std::unordered_set<const T*>& vals) {
return sorted;
}
// TODO(b/203101078): remove pragmas that suppresses uninitialized warnings when
// clang bug is fixed.
inline void MuteWuninitialized(Formatter& format) {
format(
"#if defined(__llvm__)\n"
" #pragma clang diagnostic push\n"
" #pragma clang diagnostic ignored \"-Wuninitialized\"\n"
"#endif // __llvm__\n");
}
inline void UnmuteWuninitialized(Formatter& format) {
format(
"#if defined(__llvm__)\n"
" #pragma clang diagnostic pop\n"
"#endif // __llvm__\n");
}
} // namespace
FileGenerator::FileGenerator(const FileDescriptor* file, const Options& options)
@ -335,7 +352,14 @@ void FileGenerator::DoIncludeFile(const std::string& google3_name,
options_.runtime_include_base, path);
}
} else {
format("#include \"$1$\"", google3_name);
std::string path = google3_name;
// The bootstrapped proto generated code needs to use the
// third_party/protobuf header paths to avoid circular dependencies.
if (options_.bootstrap) {
path = StringReplace(google3_name, "net/proto2/public",
"third_party/protobuf", false);
}
format("#include \"$1$\"", path);
}
if (do_export) {
@ -428,26 +452,72 @@ void FileGenerator::GenerateSourceIncludes(io::Printer* printer) {
format("// @@protoc_insertion_point(includes)\n");
IncludeFile("net/proto2/public/port_def.inc", printer);
}
void FileGenerator::GenerateSourcePrelude(io::Printer* printer) {
Formatter format(printer, variables_);
// For MSVC builds, we use #pragma init_seg to move the initialization of our
// libraries to happen before the user code.
// This worksaround the fact that MSVC does not do constant initializers when
// required by the standard.
format("\nPROTOBUF_PRAGMA_INIT_SEG\n");
// Generate convenience aliases.
format(
"\n"
"namespace _pb = ::$1$;\n"
"namespace _pbi = _pb::internal;\n",
ProtobufNamespace(options_));
if (HasGeneratedMethods(file_, options_) &&
options_.tctable_mode != Options::kTCTableNever) {
format("namespace _fl = _pbi::field_layout;\n");
}
format("\n");
}
void FileGenerator::GenerateSourceDefaultInstance(int idx,
io::Printer* printer) {
Formatter format(printer, variables_);
MessageGenerator* generator = message_generators_[idx].get();
// Generate the split instance first because it's needed in the constexpr
// constructor.
if (ShouldSplit(generator->descriptor_, options_)) {
// Use a union to disable the destructor of the _instance member.
// We can constant initialize, but the object will still have a non-trivial
// destructor that we need to elide.
format(
"struct $1$ {\n"
" PROTOBUF_CONSTEXPR $1$()\n"
" : _instance{",
DefaultInstanceType(generator->descriptor_, options_,
/*split=*/true));
generator->GenerateInitDefaultSplitInstance(printer);
format(
"} {}\n"
" ~$1$() {}\n"
" union {\n"
" $2$ _instance;\n"
" };\n"
"};\n",
DefaultInstanceType(generator->descriptor_, options_, /*split=*/true),
StrCat(generator->classname_, "::Impl_::Split"));
// NO_DESTROY is not necessary for correctness. The empty destructor is
// enough. However, the empty destructor fails to be elided in some
// configurations (like non-opt or with certain sanitizers). NO_DESTROY is
// there just to improve performance and binary size in these builds.
format(
"PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT "
"PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 $1$ $2$;\n",
DefaultInstanceType(generator->descriptor_, options_, /*split=*/true),
DefaultInstanceName(generator->descriptor_, options_, /*split=*/true));
}
generator->GenerateConstexprConstructor(printer);
// Use a union to disable the destructor of the _instance member.
// We can constant initialize, but the object will still have a non-trivial
// destructor that we need to elide.
format(
"struct $1$ {\n"
" constexpr $1$()\n"
" : _instance(::$proto_ns$::internal::ConstantInitialized{}) {}\n"
" PROTOBUF_CONSTEXPR $1$()\n"
" : _instance(::_pbi::ConstantInitialized{}) {}\n"
" ~$1$() {}\n"
" union {\n"
" $2$ _instance;\n"
@ -455,32 +525,32 @@ void FileGenerator::GenerateSourceDefaultInstance(int idx,
"};\n",
DefaultInstanceType(generator->descriptor_, options_),
generator->classname_);
// NO_DESTROY is not necessary for correctness. The empty destructor is
// enough. However, the empty destructor fails to be elided in some
// configurations (like non-opt or with certain sanitizers). NO_DESTROY is
// there just to improve performance and binary size in these builds.
format("PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT $1$ $2$;\n",
DefaultInstanceType(generator->descriptor_, options_),
DefaultInstanceName(generator->descriptor_, options_));
format(
"PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT "
"PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 $1$ $2$;\n",
DefaultInstanceType(generator->descriptor_, options_),
DefaultInstanceName(generator->descriptor_, options_));
for (int i = 0; i < generator->descriptor_->field_count(); i++) {
const FieldDescriptor* field = generator->descriptor_->field(i);
if (IsStringInlined(field, options_)) {
// Force the initialization of the inlined string in the default instance.
format(
"PROTOBUF_ATTRIBUTE_INIT_PRIORITY std::true_type "
"$1$::_init_inline_$2$_ = "
"($3$._instance.$2$_.Init(), std::true_type{});\n",
"PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 std::true_type "
"$1$::Impl_::_init_inline_$2$_ = "
"($3$._instance.$4$.Init(), std::true_type{});\n",
ClassName(generator->descriptor_), FieldName(field),
DefaultInstanceName(generator->descriptor_, options_));
DefaultInstanceName(generator->descriptor_, options_),
FieldMemberName(field, ShouldSplit(field, options_)));
}
}
if (options_.lite_implicit_weak_fields) {
format("$1$* $2$ = &$3$;\n",
DefaultInstanceType(generator->descriptor_, options_),
DefaultInstancePtr(generator->descriptor_, options_),
DefaultInstanceName(generator->descriptor_, options_));
format(
"PROTOBUF_CONSTINIT const void* $1$ =\n"
" &$2$;\n",
DefaultInstancePtr(generator->descriptor_, options_),
DefaultInstanceName(generator->descriptor_, options_));
}
}
@ -534,11 +604,10 @@ void FileGenerator::GenerateInternalForwardDeclarations(
for (auto instance : Sorted(refs.weak_default_instances)) {
ns.ChangeTo(Namespace(instance, options_));
if (options_.lite_implicit_weak_fields) {
format("extern $1$ $2$;\n", DefaultInstanceType(instance, options_),
DefaultInstanceName(instance, options_));
format("__attribute__((weak)) $1$* $2$ = nullptr;\n",
DefaultInstanceType(instance, options_),
DefaultInstancePtr(instance, options_));
format(
"PROTOBUF_CONSTINIT __attribute__((weak)) const void* $1$ =\n"
" &::_pbi::implicit_weak_message_default_instance;\n",
DefaultInstancePtr(instance, options_));
} else {
format("extern __attribute__((weak)) $1$ $2$;\n",
DefaultInstanceType(instance, options_),
@ -549,8 +618,7 @@ void FileGenerator::GenerateInternalForwardDeclarations(
for (auto file : Sorted(refs.weak_reflection_files)) {
format(
"extern __attribute__((weak)) const "
"::$proto_ns$::internal::DescriptorTable $1$;\n",
"extern __attribute__((weak)) const ::_pbi::DescriptorTable $1$;\n",
DescriptorTableName(file, options_));
}
}
@ -558,6 +626,9 @@ void FileGenerator::GenerateInternalForwardDeclarations(
void FileGenerator::GenerateSourceForMessage(int idx, io::Printer* printer) {
Formatter format(printer, variables_);
GenerateSourceIncludes(printer);
GenerateSourcePrelude(printer);
if (IsAnyMessage(file_, options_)) MuteWuninitialized(format);
CrossFileReferences refs;
ForEachField(message_generators_[idx]->descriptor_,
@ -586,6 +657,8 @@ void FileGenerator::GenerateSourceForMessage(int idx, io::Printer* printer) {
message_generators_[idx]->GenerateSourceInProto2Namespace(printer);
}
if (IsAnyMessage(file_, options_)) UnmuteWuninitialized(format);
format(
"\n"
"// @@protoc_insertion_point(global_scope)\n");
@ -594,6 +667,7 @@ void FileGenerator::GenerateSourceForMessage(int idx, io::Printer* printer) {
void FileGenerator::GenerateSourceForExtension(int idx, io::Printer* printer) {
Formatter format(printer, variables_);
GenerateSourceIncludes(printer);
GenerateSourcePrelude(printer);
NamespaceOpener ns(Namespace(file_, options_), format);
extension_generators_[idx]->GenerateDefinition(printer);
}
@ -601,10 +675,9 @@ void FileGenerator::GenerateSourceForExtension(int idx, io::Printer* printer) {
void FileGenerator::GenerateGlobalSource(io::Printer* printer) {
Formatter format(printer, variables_);
GenerateSourceIncludes(printer);
GenerateSourcePrelude(printer);
{
GenerateTables(printer);
// Define the code to initialize reflection. This code uses a global
// constructor to register reflection data with the runtime pre-main.
if (HasDescriptorMethods(file_, options_)) {
@ -623,10 +696,13 @@ void FileGenerator::GenerateGlobalSource(io::Printer* printer) {
void FileGenerator::GenerateSource(io::Printer* printer) {
Formatter format(printer, variables_);
GenerateSourceIncludes(printer);
GenerateSourcePrelude(printer);
CrossFileReferences refs;
GetCrossFileReferencesForFile(file_, &refs);
GenerateInternalForwardDeclarations(refs, printer);
if (IsAnyMessage(file_, options_)) MuteWuninitialized(format);
{
NamespaceOpener ns(Namespace(file_, options_), format);
@ -637,8 +713,6 @@ void FileGenerator::GenerateSource(io::Printer* printer) {
}
{
GenerateTables(printer);
if (HasDescriptorMethods(file_, options_)) {
// Define the code to initialize reflection. This code uses a global
// constructor to register reflection data with the runtime pre-main.
@ -695,6 +769,8 @@ void FileGenerator::GenerateSource(io::Printer* printer) {
"\n"
"// @@protoc_insertion_point(global_scope)\n");
if (IsAnyMessage(file_, options_)) UnmuteWuninitialized(format);
IncludeFile("net/proto2/public/port_undef.inc", printer);
}
@ -702,31 +778,30 @@ void FileGenerator::GenerateReflectionInitializationCode(io::Printer* printer) {
Formatter format(printer, variables_);
if (!message_generators_.empty()) {
format("static ::$proto_ns$::Metadata $file_level_metadata$[$1$];\n",
format("static ::_pb::Metadata $file_level_metadata$[$1$];\n",
message_generators_.size());
}
if (!enum_generators_.empty()) {
format(
"static "
"const ::$proto_ns$::EnumDescriptor* "
"static const ::_pb::EnumDescriptor* "
"$file_level_enum_descriptors$[$1$];\n",
enum_generators_.size());
} else {
format(
"static "
"constexpr ::$proto_ns$::EnumDescriptor const** "
"constexpr ::_pb::EnumDescriptor const** "
"$file_level_enum_descriptors$ = nullptr;\n");
}
if (HasGenericServices(file_, options_) && file_->service_count() > 0) {
format(
"static "
"const ::$proto_ns$::ServiceDescriptor* "
"const ::_pb::ServiceDescriptor* "
"$file_level_service_descriptors$[$1$];\n",
file_->service_count());
} else {
format(
"static "
"constexpr ::$proto_ns$::ServiceDescriptor const** "
"constexpr ::_pb::ServiceDescriptor const** "
"$file_level_service_descriptors$ = nullptr;\n");
}
@ -744,7 +819,7 @@ void FileGenerator::GenerateReflectionInitializationCode(io::Printer* printer) {
format.Outdent();
format(
"};\n"
"static const ::$proto_ns$::internal::MigrationSchema schemas[] "
"static const ::_pbi::MigrationSchema schemas[] "
"PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {\n");
format.Indent();
{
@ -758,16 +833,13 @@ void FileGenerator::GenerateReflectionInitializationCode(io::Printer* printer) {
format.Outdent();
format(
"};\n"
"\nstatic "
"::$proto_ns$::Message const * const file_default_instances[] = {\n");
"\nstatic const ::_pb::Message* const file_default_instances[] = {\n");
format.Indent();
for (int i = 0; i < message_generators_.size(); i++) {
const Descriptor* descriptor = message_generators_[i]->descriptor_;
format(
"reinterpret_cast<const "
"::$proto_ns$::Message*>(&$1$::_$2$_default_instance_),\n",
Namespace(descriptor, options_), // 1
ClassName(descriptor)); // 2
format("&$1$::_$2$_default_instance_._instance,\n",
Namespace(descriptor, options_), // 1
ClassName(descriptor)); // 2
}
format.Outdent();
format(
@ -778,10 +850,8 @@ void FileGenerator::GenerateReflectionInitializationCode(io::Printer* printer) {
format(
// MSVC doesn't like empty arrays, so we add a dummy.
"const $uint32$ $tablename$::offsets[1] = {};\n"
"static constexpr ::$proto_ns$::internal::MigrationSchema* schemas = "
"nullptr;"
"\n"
"static constexpr ::$proto_ns$::Message* const* "
"static constexpr ::_pbi::MigrationSchema* schemas = nullptr;\n"
"static constexpr ::_pb::Message* const* "
"file_default_instances = nullptr;\n"
"\n");
}
@ -836,7 +906,7 @@ void FileGenerator::GenerateReflectionInitializationCode(io::Printer* printer) {
// Build array of DescriptorTable deps.
if (num_deps > 0) {
format(
"static const ::$proto_ns$::internal::DescriptorTable*const "
"static const ::_pbi::DescriptorTable* const "
"$desc_table$_deps[$1$] = {\n",
num_deps);
@ -856,13 +926,14 @@ void FileGenerator::GenerateReflectionInitializationCode(io::Printer* printer) {
// so disable for now.
bool eager = false;
format(
"static ::$proto_ns$::internal::once_flag $desc_table$_once;\n"
"const ::$proto_ns$::internal::DescriptorTable $desc_table$ = {\n"
" false, $1$, $2$, $3$, \"$filename$\", \n"
" &$desc_table$_once, $4$, $5$, $6$,\n"
" schemas, file_default_instances, $tablename$::offsets,\n"
" $7$, $file_level_enum_descriptors$, "
"$file_level_service_descriptors$,\n"
"static ::_pbi::once_flag $desc_table$_once;\n"
"const ::_pbi::DescriptorTable $desc_table$ = {\n"
" false, $1$, $2$, $3$,\n"
" \"$filename$\",\n"
" &$desc_table$_once, $4$, $5$, $6$,\n"
" schemas, file_default_instances, $tablename$::offsets,\n"
" $7$, $file_level_enum_descriptors$,\n"
" $file_level_service_descriptors$,\n"
"};\n"
// This function exists to be marked as weak.
// It can significantly speed up compilation by breaking up LLVM's SCC in
@ -875,7 +946,7 @@ void FileGenerator::GenerateReflectionInitializationCode(io::Printer* printer) {
// vtables -> GetMetadata
// By adding a weak function here we break the connection from the
// individual vtables back into the descriptor table.
"PROTOBUF_ATTRIBUTE_WEAK const ::$proto_ns$::internal::DescriptorTable* "
"PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* "
"$desc_table$_getter() {\n"
" return &$desc_table$;\n"
"}\n"
@ -893,127 +964,17 @@ void FileGenerator::GenerateReflectionInitializationCode(io::Printer* printer) {
if (file_->name() != "net/proto2/proto/descriptor.proto") {
format(
"// Force running AddDescriptors() at dynamic initialization time.\n"
"PROTOBUF_ATTRIBUTE_INIT_PRIORITY "
"static ::$proto_ns$::internal::AddDescriptorsRunner "
"$1$(&$desc_table$);\n",
"PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 "
"static ::_pbi::AddDescriptorsRunner $1$(&$desc_table$);\n",
UniqueName("dynamic_init_dummy", file_, options_));
}
}
void FileGenerator::GenerateTables(io::Printer* printer) {
Formatter format(printer, variables_);
if (options_.table_driven_parsing) {
// TODO(ckennelly): Gate this with the same options flag to enable
// table-driven parsing.
format(
"PROTOBUF_CONSTEXPR_VAR ::$proto_ns$::internal::ParseTableField\n"
" const $tablename$::entries[] "
"PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {\n");
format.Indent();
std::vector<size_t> entries;
size_t count = 0;
for (int i = 0; i < message_generators_.size(); i++) {
size_t value = message_generators_[i]->GenerateParseOffsets(printer);
entries.push_back(value);
count += value;
}
// We need these arrays to exist, and MSVC does not like empty arrays.
if (count == 0) {
format("{0, 0, 0, ::$proto_ns$::internal::kInvalidMask, 0, 0},\n");
}
format.Outdent();
format(
"};\n"
"\n"
"PROTOBUF_CONSTEXPR_VAR "
"::$proto_ns$::internal::AuxiliaryParseTableField\n"
" const $tablename$::aux[] "
"PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {\n");
format.Indent();
std::vector<size_t> aux_entries;
count = 0;
for (int i = 0; i < message_generators_.size(); i++) {
size_t value = message_generators_[i]->GenerateParseAuxTable(printer);
aux_entries.push_back(value);
count += value;
}
if (count == 0) {
format("::$proto_ns$::internal::AuxiliaryParseTableField(),\n");
}
format.Outdent();
format(
"};\n"
"PROTOBUF_CONSTEXPR_VAR ::$proto_ns$::internal::ParseTable const\n"
" $tablename$::schema[] "
"PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {\n");
format.Indent();
size_t offset = 0;
size_t aux_offset = 0;
for (int i = 0; i < message_generators_.size(); i++) {
message_generators_[i]->GenerateParseTable(printer, offset, aux_offset);
offset += entries[i];
aux_offset += aux_entries[i];
}
if (message_generators_.empty()) {
format("{ nullptr, nullptr, 0, -1, -1, false },\n");
}
format.Outdent();
format(
"};\n"
"\n");
}
if (!message_generators_.empty() && options_.table_driven_serialization) {
format(
"const ::$proto_ns$::internal::FieldMetadata "
"$tablename$::field_metadata[] "
"= {\n");
format.Indent();
std::vector<int> field_metadata_offsets;
int idx = 0;
for (int i = 0; i < message_generators_.size(); i++) {
field_metadata_offsets.push_back(idx);
idx += message_generators_[i]->GenerateFieldMetadata(printer);
}
field_metadata_offsets.push_back(idx);
format.Outdent();
format(
"};\n"
"const ::$proto_ns$::internal::SerializationTable "
"$tablename$::serialization_table[] = {\n");
format.Indent();
// We rely on the order we layout the tables to match the order we
// calculate them with FlattenMessagesInFile, so we check here that
// these match exactly.
std::vector<const Descriptor*> calculated_order =
FlattenMessagesInFile(file_);
GOOGLE_CHECK_EQ(calculated_order.size(), message_generators_.size());
for (int i = 0; i < message_generators_.size(); i++) {
GOOGLE_CHECK_EQ(calculated_order[i], message_generators_[i]->descriptor_);
format("{$1$, $tablename$::field_metadata + $2$},\n",
field_metadata_offsets[i + 1] - field_metadata_offsets[i], // 1
field_metadata_offsets[i]); // 2
}
format.Outdent();
format(
"};\n"
"\n");
}
}
class FileGenerator::ForwardDeclarations {
public:
void AddMessage(const Descriptor* d) { classes_[ClassName(d)] = d; }
void AddEnum(const EnumDescriptor* d) { enums_[ClassName(d)] = d; }
void AddSplit(const Descriptor* d) { splits_[ClassName(d)] = d; }
void Print(const Formatter& format, const Options& options) const {
for (const auto& p : enums_) {
@ -1034,6 +995,14 @@ class FileGenerator::ForwardDeclarations {
class_desc, classname, DefaultInstanceType(class_desc, options),
DefaultInstanceName(class_desc, options));
}
for (const auto& p : splits_) {
const Descriptor* class_desc = p.second;
format(
"struct $1$;\n"
"$dllexport_decl $extern $1$ $2$;\n",
DefaultInstanceType(class_desc, options, /*split=*/true),
DefaultInstanceName(class_desc, options, /*split=*/true));
}
}
void PrintTopLevelDecl(const Formatter& format,
@ -1049,6 +1018,7 @@ class FileGenerator::ForwardDeclarations {
private:
std::map<std::string, const Descriptor*> classes_;
std::map<std::string, const EnumDescriptor*> enums_;
std::map<std::string, const Descriptor*> splits_;
};
static void PublicImportDFS(const FileDescriptor* fd,
@ -1094,6 +1064,12 @@ void FileGenerator::GenerateForwardDeclarations(io::Printer* printer) {
if (d && !public_set.count(d->file()))
decls[Namespace(d, options_)].AddEnum(d);
}
for (const auto& mg : message_generators_) {
const Descriptor* d = mg->descriptor_;
if ((d != nullptr) && (public_set.count(d->file()) == 0u) &&
ShouldSplit(mg->descriptor_, options_))
decls[Namespace(d, options_)].AddSplit(d);
}
{
NamespaceOpener ns(format);
@ -1185,7 +1161,6 @@ void FileGenerator::GenerateLibraryIncludes(io::Printer* printer) {
if (HasSimpleBaseClasses(file_, options_)) {
IncludeFile("net/proto2/public/generated_message_bases.h", printer);
}
IncludeFile("net/proto2/public/generated_message_table_driven.h", printer);
if (HasGeneratedMethods(file_, options_) &&
options_.tctable_mode != Options::kTCTableNever) {
IncludeFile("net/proto2/public/generated_message_tctable_decl.h", printer);
@ -1297,20 +1272,8 @@ void FileGenerator::GenerateGlobalStateFunctionDeclarations(
"\n"
"// Internal implementation detail -- do not use these members.\n"
"struct $dllexport_decl $$tablename$ {\n"
// These tables describe how to serialize and parse messages. Used
// for table driven code.
" static const ::$proto_ns$::internal::ParseTableField entries[]\n"
" PROTOBUF_SECTION_VARIABLE(protodesc_cold);\n"
" static const ::$proto_ns$::internal::AuxiliaryParseTableField aux[]\n"
" PROTOBUF_SECTION_VARIABLE(protodesc_cold);\n"
" static const ::$proto_ns$::internal::ParseTable schema[$1$]\n"
" PROTOBUF_SECTION_VARIABLE(protodesc_cold);\n"
" static const ::$proto_ns$::internal::FieldMetadata field_metadata[];\n"
" static const ::$proto_ns$::internal::SerializationTable "
"serialization_table[];\n"
" static const $uint32$ offsets[];\n"
"};\n",
std::max(size_t(1), message_generators_.size()));
"};\n");
if (HasDescriptorMethods(file_, options_)) {
format(
"$dllexport_decl $extern const ::$proto_ns$::internal::DescriptorTable "

9
r5dev/thirdparty/protobuf/compiler/cpp/cpp_file.h → r5dev/thirdparty/protobuf/compiler/cpp/file.h vendored
View File

@ -40,11 +40,12 @@
#include <set>
#include <string>
#include <vector>
#include <thirdparty/protobuf/stubs/common.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_field.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_helpers.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_options.h>
#include <thirdparty/protobuf/compiler/cpp/field.h>
#include <thirdparty/protobuf/compiler/cpp/helpers.h>
#include <thirdparty/protobuf/compiler/scc.h>
#include <thirdparty/protobuf/compiler/cpp/options.h>
namespace google {
namespace protobuf {
@ -122,11 +123,11 @@ class FileGenerator {
void GenerateInternalForwardDeclarations(const CrossFileReferences& refs,
io::Printer* printer);
void GenerateSourceIncludes(io::Printer* printer);
void GenerateSourcePrelude(io::Printer* printer);
void GenerateSourceDefaultInstance(int idx, io::Printer* printer);
void GenerateInitForSCC(const SCC* scc, const CrossFileReferences& refs,
io::Printer* printer);
void GenerateTables(io::Printer* printer);
void GenerateReflectionInitializationCode(io::Printer* printer);
// For other imports, generates their forward-declarations.

34
r5dev/thirdparty/protobuf/compiler/cpp/cpp_generator.cc → r5dev/thirdparty/protobuf/compiler/cpp/generator.cc vendored
View File

@ -32,7 +32,7 @@
// Based on original Protocol Buffers design by
// Sanjay Ghemawat, Jeff Dean, and others.
#include <thirdparty/protobuf/compiler/cpp/cpp_generator.h>
#include <thirdparty/protobuf/compiler/cpp/generator.h>
#include <memory>
#include <string>
@ -40,11 +40,11 @@
#include <vector>
#include <thirdparty/protobuf/stubs/strutil.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_file.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_helpers.h>
#include <thirdparty/protobuf/descriptor.pb.h>
#include <thirdparty/protobuf/io/printer.h>
#include <thirdparty/protobuf/io/zero_copy_stream.h>
#include <thirdparty/protobuf/compiler/cpp/file.h>
#include <thirdparty/protobuf/compiler/cpp/helpers.h>
#include <thirdparty/protobuf/descriptor.pb.h>
namespace google {
namespace protobuf {
@ -82,6 +82,12 @@ bool CppGenerator::Generate(const FileDescriptor* file,
// FOO_EXPORT is a macro which should expand to __declspec(dllexport) or
// __declspec(dllimport) depending on what is being compiled.
//
// If the proto_h option is passed to the compiler, we will generate all
// classes and enums so that they can be forward-declared from files that
// need them from imports.
//
// If the lite option is passed to the compiler, we will generate the
// current files and all transitive dependencies using the LITE runtime.
Options file_options;
file_options.opensource_runtime = opensource_runtime_;
@ -109,8 +115,10 @@ bool CppGenerator::Generate(const FileDescriptor* file,
file_options.lite_implicit_weak_fields = true;
if (!options[i].second.empty()) {
file_options.num_cc_files =
strto32(options[i].second.c_str(), NULL, 10);
strto32(options[i].second.c_str(), nullptr, 10);
}
} else if (options[i].first == "proto_h") {
file_options.proto_h = true;
} else if (options[i].first == "annotate_accessor") {
file_options.annotate_accessor = true;
} else if (options[i].first == "inject_field_listener_events") {
@ -127,14 +135,14 @@ bool CppGenerator::Generate(const FileDescriptor* file,
.insert(options[i].second.substr(pos, next_pos - pos));
pos = next_pos + 1;
} while (pos < options[i].second.size());
} else if (options[i].first == "eagerly_verified_lazy") {
file_options.eagerly_verified_lazy = true;
} else if (options[i].first == "verified_lazy") {
file_options.unverified_lazy = false;
} else if (options[i].first == "unverified_lazy_message_sets") {
file_options.unverified_lazy_message_sets = true;
} else if (options[i].first == "message_owned_arena_trial") {
file_options.message_owned_arena_trial = true;
} else if (options[i].first == "force_eagerly_verified_lazy") {
file_options.force_eagerly_verified_lazy = true;
} else if (options[i].first == "table_driven_parsing") {
file_options.table_driven_parsing = true;
} else if (options[i].first == "table_driven_serialization") {
file_options.table_driven_serialization = true;
} else if (options[i].first == "experimental_tail_call_table_mode") {
if (options[i].second == "never") {
file_options.tctable_mode = Options::kTCTableNever;
@ -183,7 +191,7 @@ bool CppGenerator::Generate(const FileDescriptor* file,
std::string info_path = basename + ".proto.h.meta";
io::Printer printer(
output.get(), '$',
file_options.annotate_headers ? &annotation_collector : NULL);
file_options.annotate_headers ? &annotation_collector : nullptr);
file_generator.GenerateProtoHeader(
&printer, file_options.annotate_headers ? info_path : "");
if (file_options.annotate_headers) {
@ -202,7 +210,7 @@ bool CppGenerator::Generate(const FileDescriptor* file,
std::string info_path = basename + ".pb.h.meta";
io::Printer printer(
output.get(), '$',
file_options.annotate_headers ? &annotation_collector : NULL);
file_options.annotate_headers ? &annotation_collector : nullptr);
file_generator.GeneratePBHeader(
&printer, file_options.annotate_headers ? info_path : "");
if (file_options.annotate_headers) {

107
r5dev/thirdparty/protobuf/compiler/cpp/generator.h vendored Normal file
View File

@ -0,0 +1,107 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Author: kenton@google.com (Kenton Varda)
// Based on original Protocol Buffers design by
// Sanjay Ghemawat, Jeff Dean, and others.
//
// Generates C++ code for a given .proto file.
#ifndef GOOGLE_PROTOBUF_COMPILER_CPP_GENERATOR_H__
#define GOOGLE_PROTOBUF_COMPILER_CPP_GENERATOR_H__
#include <string>
#include <thirdparty/protobuf/compiler/code_generator.h>
// Must be included last.
#include <thirdparty/protobuf/port_def.inc>
namespace google {
namespace protobuf {
namespace compiler {
namespace cpp {
// CodeGenerator implementation which generates a C++ source file and
// header. If you create your own protocol compiler binary and you want
// it to support C++ output, you can do so by registering an instance of this
// CodeGenerator with the CommandLineInterface in your main() function.
class PROTOC_EXPORT CppGenerator : public CodeGenerator {
public:
CppGenerator();
~CppGenerator() override;
enum class Runtime {
kGoogle3, // Use the internal google3 runtime.
kOpensource, // Use the open-source runtime.
// Use the open-source runtime with google3 #include paths. We make these
// absolute to avoid ambiguity, so the runtime will be #included like:
// #include "third_party/protobuf/.../google/protobuf/message.h"
kOpensourceGoogle3
};
void set_opensource_runtime(bool opensource) {
opensource_runtime_ = opensource;
}
// If set to a non-empty string, generated code will do:
// #include "<BASE>/google/protobuf/message.h"
// instead of:
// #include <thirdparty/protobuf/message.h>
// This has no effect if opensource_runtime = false.
void set_runtime_include_base(const std::string& base) {
runtime_include_base_ = base;
}
// implements CodeGenerator ----------------------------------------
bool Generate(const FileDescriptor* file, const std::string& parameter,
GeneratorContext* generator_context,
std::string* error) const override;
uint64_t GetSupportedFeatures() const override {
// We don't fully support this yet, but this is needed to unblock the tests,
// and we will have full support before the experimental flag is removed.
return FEATURE_PROTO3_OPTIONAL;
}
private:
bool opensource_runtime_ = true;
std::string runtime_include_base_;
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CppGenerator);
};
} // namespace cpp
} // namespace compiler
} // namespace protobuf
} // namespace google
#include <thirdparty/protobuf/port_undef.inc>
#endif // GOOGLE_PROTOBUF_COMPILER_CPP_GENERATOR_H__

146
r5dev/thirdparty/protobuf/compiler/cpp/cpp_helpers.cc → r5dev/thirdparty/protobuf/compiler/cpp/helpers.cc vendored
View File

@ -32,22 +32,23 @@
// Based on original Protocol Buffers design by
// Sanjay Ghemawat, Jeff Dean, and others.
#include <thirdparty/protobuf/compiler/cpp/cpp_helpers.h>
#include <thirdparty/protobuf/compiler/cpp/helpers.h>
#include <cstdint>
#include <functional>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <unordered_set>
#include <vector>
#include <thirdparty/protobuf/stubs/common.h>
#include <thirdparty/protobuf/stubs/logging.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_options.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_names.h>
#include <thirdparty/protobuf/descriptor.pb.h>
#include <thirdparty/protobuf/descriptor.h>
#include <thirdparty/protobuf/compiler/cpp/names.h>
#include <thirdparty/protobuf/compiler/cpp/options.h>
#include <thirdparty/protobuf/descriptor.pb.h>
#include <thirdparty/protobuf/compiler/scc.h>
#include <thirdparty/protobuf/io/printer.h>
#include <thirdparty/protobuf/io/zero_copy_stream.h>
@ -178,18 +179,53 @@ void SetIntVar(const Options& options, const std::string& type,
std::map<std::string, std::string>* variables) {
(*variables)[type] = IntTypeName(options, type);
}
bool IsEagerlyVerifiedLazyImpl(const FieldDescriptor* field,
const Options& options,
MessageSCCAnalyzer* scc_analyzer) {
// Returns true if the message can potentially allocate memory for its field.
// This is used to determine if message-owned arena will be useful.
bool AllocExpected(const Descriptor* descriptor) {
return false;
}
// Describes different approaches to detect non-canonical int32 encoding. Only
// kNever or kAlways is eligible for *simple* verification methods.
enum class VerifyInt32Type {
kCustom, // Only check if field number matches.
kNever, // Do not check.
kAlways, // Always check.
};
inline VerifySimpleType VerifyInt32TypeToVerifyCustom(VerifyInt32Type t) {
static VerifySimpleType kCustomTypes[] = {
VerifySimpleType::kCustom, VerifySimpleType::kCustomInt32Never,
VerifySimpleType::kCustomInt32Always};
return kCustomTypes[static_cast<int32_t>(t) -
static_cast<int32_t>(VerifyInt32Type::kCustom)];
}
} // namespace
bool IsLazy(const FieldDescriptor* field, const Options& options,
MessageSCCAnalyzer* scc_analyzer) {
return IsLazilyVerifiedLazy(field, options) ||
IsEagerlyVerifiedLazyImpl(field, options, scc_analyzer);
IsEagerlyVerifiedLazy(field, options, scc_analyzer);
}
// Returns true if "field" is a message field that is backed by LazyField per
// profile (go/pdlazy).
inline bool IsEagerlyVerifiedLazyByProfile(const FieldDescriptor* field,
const Options& options,
MessageSCCAnalyzer* scc_analyzer) {
return false;
}
bool IsEagerlyVerifiedLazy(const FieldDescriptor* field, const Options& options,
MessageSCCAnalyzer* scc_analyzer) {
return false;
}
bool IsLazilyVerifiedLazy(const FieldDescriptor* field,
const Options& options) {
return false;
}
void SetCommonVars(const Options& options,
@ -229,6 +265,23 @@ void SetCommonVars(const Options& options,
(*variables)["string"] = "std::string";
}
void SetCommonMessageDataVariables(
const Descriptor* descriptor,
std::map<std::string, std::string>* variables) {
std::string prefix = IsMapEntryMessage(descriptor) ? "" : "_impl_.";
(*variables)["any_metadata"] = prefix + "_any_metadata_";
(*variables)["cached_size"] = prefix + "_cached_size_";
(*variables)["extensions"] = prefix + "_extensions_";
(*variables)["has_bits"] = prefix + "_has_bits_";
(*variables)["inlined_string_donated_array"] =
prefix + "_inlined_string_donated_";
(*variables)["oneof_case"] = prefix + "_oneof_case_";
(*variables)["tracker"] = "Impl_::_tracker_";
(*variables)["weak_field_map"] = prefix + "_weak_field_map_";
(*variables)["split"] = prefix + "_split_";
(*variables)["cached_split_ptr"] = "cached_split_ptr";
}
void SetUnknownFieldsVariable(const Descriptor* descriptor,
const Options& options,
std::map<std::string, std::string>* variables) {
@ -391,29 +444,32 @@ std::string Namespace(const EnumDescriptor* d, const Options& options) {
}
std::string DefaultInstanceType(const Descriptor* descriptor,
const Options& options) {
return ClassName(descriptor) + "DefaultTypeInternal";
const Options& /*options*/, bool split) {
return ClassName(descriptor) + (split ? "__Impl_Split" : "") +
"DefaultTypeInternal";
}
std::string DefaultInstanceName(const Descriptor* descriptor,
const Options& options) {
return "_" + ClassName(descriptor, false) + "_default_instance_";
const Options& /*options*/, bool split) {
return "_" + ClassName(descriptor, false) + (split ? "__Impl_Split" : "") +
"_default_instance_";
}
std::string DefaultInstancePtr(const Descriptor* descriptor,
const Options& options) {
return DefaultInstanceName(descriptor, options) + "ptr_";
const Options& options, bool split) {
return DefaultInstanceName(descriptor, options, split) + "ptr_";
}
std::string QualifiedDefaultInstanceName(const Descriptor* descriptor,
const Options& options) {
const Options& options, bool split) {
return QualifiedFileLevelSymbol(
descriptor->file(), DefaultInstanceName(descriptor, options), options);
descriptor->file(), DefaultInstanceName(descriptor, options, split),
options);
}
std::string QualifiedDefaultInstancePtr(const Descriptor* descriptor,
const Options& options) {
return QualifiedDefaultInstanceName(descriptor, options) + "ptr_";
const Options& options, bool split) {
return QualifiedDefaultInstanceName(descriptor, options, split) + "ptr_";
}
std::string DescriptorTableName(const FileDescriptor* file,
@ -453,6 +509,19 @@ std::string FieldName(const FieldDescriptor* field) {
return result;
}
std::string FieldMemberName(const FieldDescriptor* field, bool split) {
StringPiece prefix =
IsMapEntryMessage(field->containing_type()) ? "" : "_impl_.";
StringPiece split_prefix = split ? "_split_->" : "";
if (field->real_containing_oneof() == nullptr) {
return StrCat(prefix, split_prefix, FieldName(field), "_");
}
// Oneof fields are never split.
GOOGLE_CHECK(!split);
return StrCat(prefix, field->containing_oneof()->name(), "_.",
FieldName(field), "_");
}
std::string OneofCaseConstantName(const FieldDescriptor* field) {
GOOGLE_DCHECK(field->containing_oneof());
std::string field_name = UnderscoresToCamelCase(field->name(), true);
@ -831,6 +900,9 @@ bool HasLazyFields(const FileDescriptor* file, const Options& options,
return false;
}
bool ShouldSplit(const Descriptor*, const Options&) { return false; }
bool ShouldSplit(const FieldDescriptor*, const Options&) { return false; }
static bool HasRepeatedFields(const Descriptor* descriptor) {
for (int i = 0; i < descriptor->field_count(); ++i) {
if (descriptor->field(i)->label() == FieldDescriptor::LABEL_REPEATED) {
@ -967,6 +1039,16 @@ bool ShouldVerify(const FileDescriptor* file, const Options& options,
return false;
}
bool IsUtf8String(const FieldDescriptor* field) {
return IsProto3(field->file()) &&
field->type() == FieldDescriptor::TYPE_STRING;
}
VerifySimpleType ShouldVerifySimple(const Descriptor* descriptor) {
(void)descriptor;
return VerifySimpleType::kCustom;
}
bool IsStringOrMessage(const FieldDescriptor* field) {
switch (field->cpp_type()) {
case FieldDescriptor::CPPTYPE_INT32:
@ -1147,7 +1229,6 @@ bool IsImplicitWeakField(const FieldDescriptor* field, const Options& options,
return UsingImplicitWeakFields(field->file(), options) &&
field->type() == FieldDescriptor::TYPE_MESSAGE &&
!field->is_required() && !field->is_map() && !field->is_extension() &&
!field->real_containing_oneof() &&
!IsWellKnownMessage(field->message_type()->file()) &&
field->message_type()->file()->name() !=
"net/proto2/proto/descriptor.proto" &&
@ -1264,7 +1345,7 @@ bool GetBootstrapBasename(const Options& options, const std::string& basename,
std::unordered_map<std::string, std::string> bootstrap_mapping{
{"net/proto2/proto/descriptor",
"net/proto2/internal/descriptor"},
"third_party/protobuf/descriptor"},
{"net/proto2/compiler/proto/plugin",
"net/proto2/compiler/proto/plugin"},
{"net/proto2/compiler/proto/profile",
@ -1297,7 +1378,7 @@ bool MaybeBootstrap(const Options& options, GeneratorContext* generator_context,
*basename = bootstrap_basename;
return false;
} else {
std::string forward_to_basename = bootstrap_basename;
const std::string& forward_to_basename = bootstrap_basename;
// Generate forwarding headers and empty .pb.cc.
{
@ -1486,8 +1567,29 @@ FileOptions_OptimizeMode GetOptimizeFor(const FileDescriptor* file,
return FileOptions::SPEED;
}
bool EnableMessageOwnedArena(const Descriptor* desc) {
inline bool IsMessageOwnedArenaEligible(const Descriptor* desc,
const Options& options) {
return GetOptimizeFor(desc->file(), options) != FileOptions::LITE_RUNTIME &&
!options.bootstrap && !options.opensource_runtime &&
AllocExpected(desc);
}
bool EnableMessageOwnedArena(const Descriptor* desc, const Options& options) {
(void)desc;
(void)options;
return false;
}
bool EnableMessageOwnedArenaTrial(const Descriptor* desc,
const Options& options) {
return false;
}
bool HasMessageFieldOrExtension(const Descriptor* desc) {
if (desc->extension_range_count() > 0) return true;
for (const auto* f : FieldRange(desc)) {
if (f->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) return true;
}
return false;
}

145
r5dev/thirdparty/protobuf/compiler/cpp/cpp_helpers.h → r5dev/thirdparty/protobuf/compiler/cpp/helpers.h vendored
View File

@ -41,10 +41,10 @@
#include <map>
#include <string>
#include <thirdparty/protobuf/compiler/cpp/cpp_options.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_names.h>
#include <thirdparty/protobuf/compiler/scc.h>
#include <thirdparty/protobuf/compiler/code_generator.h>
#include <thirdparty/protobuf/compiler/cpp/names.h>
#include <thirdparty/protobuf/compiler/cpp/options.h>
#include <thirdparty/protobuf/descriptor.pb.h>
#include <thirdparty/protobuf/io/printer.h>
#include <thirdparty/protobuf/descriptor.h>
@ -59,6 +59,8 @@ namespace protobuf {
namespace compiler {
namespace cpp {
enum class ArenaDtorNeeds { kNone = 0, kOnDemand = 1, kRequired = 2 };
inline std::string ProtobufNamespace(const Options& /* options */) {
return "PROTOBUF_NAMESPACE_ID";
}
@ -85,6 +87,11 @@ extern const char kThinSeparator[];
void SetCommonVars(const Options& options,
std::map<std::string, std::string>* variables);
// Variables to access message data from the message scope.
void SetCommonMessageDataVariables(
const Descriptor* descriptor,
std::map<std::string, std::string>* variables);
void SetUnknownFieldsVariable(const Descriptor* descriptor,
const Options& options,
std::map<std::string, std::string>* variables);
@ -121,11 +128,11 @@ std::string QualifiedClassName(const EnumDescriptor* d);
// Returns the non-nested type name for the given type. If "qualified" is
// true, prefix the type with the full namespace. For example, if you had:
// package foo.bar;
// message Baz { message Qux {} }
// Then the qualified ClassName for Qux would be:
// ::foo::bar::Baz_Qux
// message Baz { message Moo {} }
// Then the qualified ClassName for Moo would be:
// ::foo::bar::Baz_Moo
// While the non-qualified version would be:
// Baz_Qux
// Baz_Moo
inline std::string ClassName(const Descriptor* descriptor, bool qualified) {
return qualified ? QualifiedClassName(descriptor, Options())
: ClassName(descriptor);
@ -146,24 +153,26 @@ std::string QualifiedExtensionName(const FieldDescriptor* d);
// Type name of default instance.
std::string DefaultInstanceType(const Descriptor* descriptor,
const Options& options);
const Options& options, bool split = false);
// Non-qualified name of the default_instance of this message.
std::string DefaultInstanceName(const Descriptor* descriptor,
const Options& options);
const Options& options, bool split = false);
// Non-qualified name of the default instance pointer. This is used only for
// implicit weak fields, where we need an extra indirection.
std::string DefaultInstancePtr(const Descriptor* descriptor,
const Options& options);
const Options& options, bool split = false);
// Fully qualified name of the default_instance of this message.
std::string QualifiedDefaultInstanceName(const Descriptor* descriptor,
const Options& options);
const Options& options,
bool split = false);
// Fully qualified name of the default instance pointer.
std::string QualifiedDefaultInstancePtr(const Descriptor* descriptor,
const Options& options);
const Options& options,
bool split = false);
// DescriptorTable variable name.
std::string DescriptorTableName(const FileDescriptor* file,
@ -186,6 +195,9 @@ std::string ResolveKeyword(const std::string& name);
// anyway, so normally this just returns field->name().
std::string FieldName(const FieldDescriptor* field);
// Returns the (unqualified) private member name for this field in C++ code.
std::string FieldMemberName(const FieldDescriptor* field, bool split);
// Returns an estimate of the compiler's alignment for the field. This
// can't guarantee to be correct because the generated code could be compiled on
// different systems with different alignment rules. The estimates below assume
@ -348,19 +360,22 @@ bool HasLazyFields(const FileDescriptor* file, const Options& options,
bool IsLazy(const FieldDescriptor* field, const Options& options,
MessageSCCAnalyzer* scc_analyzer);
inline bool IsLazilyVerifiedLazy(const FieldDescriptor* field,
const Options& options) {
return field->options().lazy() && !field->is_repeated() &&
field->type() == FieldDescriptor::TYPE_MESSAGE &&
GetOptimizeFor(field->file(), options) != FileOptions::LITE_RUNTIME &&
!options.opensource_runtime;
// Is this an explicit (non-profile driven) lazy field, as denoted by
// lazy/unverified_lazy in the descriptor?
inline bool IsExplicitLazy(const FieldDescriptor* field) {
return field->options().lazy() || field->options().unverified_lazy();
}
inline bool IsEagerlyVerifiedLazy(const FieldDescriptor* field,
const Options& options,
MessageSCCAnalyzer* scc_analyzer) {
return IsLazy(field, options, scc_analyzer) && !field->options().lazy();
}
bool IsEagerlyVerifiedLazy(const FieldDescriptor* field, const Options& options,
MessageSCCAnalyzer* scc_analyzer);
bool IsLazilyVerifiedLazy(const FieldDescriptor* field, const Options& options);
// Is the given message being split (go/pdsplit)?
bool ShouldSplit(const Descriptor* desc, const Options& options);
// Is the given field being split out?
bool ShouldSplit(const FieldDescriptor* field, const Options& options);
inline bool IsFieldUsed(const FieldDescriptor* /* field */,
const Options& /* options */) {
@ -468,10 +483,49 @@ inline bool IsCrossFileMessage(const FieldDescriptor* field) {
}
inline std::string MakeDefaultName(const FieldDescriptor* field) {
return "_i_give_permission_to_break_this_code_default_" + FieldName(field) +
"_";
return StrCat("_i_give_permission_to_break_this_code_default_",
FieldName(field), "_");
}
// Semantically distinct from MakeDefaultName in that it gives the C++ code
// referencing a default field from the message scope, rather than just the
// variable name.
// For example, declarations of default variables should always use just
// MakeDefaultName to produce code like:
// Type _i_give_permission_to_break_this_code_default_field_;
//
// Code that references these should use MakeDefaultFieldName, in case the field
// exists at some nested level like:
// internal_container_._i_give_permission_to_break_this_code_default_field_;
inline std::string MakeDefaultFieldName(const FieldDescriptor* field) {
return StrCat("Impl_::", MakeDefaultName(field));
}
inline std::string MakeVarintCachedSizeName(const FieldDescriptor* field) {
return StrCat("_", FieldName(field), "_cached_byte_size_");
}
// Semantically distinct from MakeVarintCachedSizeName in that it gives the C++
// code referencing the object from the message scope, rather than just the
// variable name.
// For example, declarations of default variables should always use just
// MakeVarintCachedSizeName to produce code like:
// Type _field_cached_byte_size_;
//
// Code that references these variables should use
// MakeVarintCachedSizeFieldName, in case the field exists at some nested level
// like:
// internal_container_._field_cached_byte_size_;
inline std::string MakeVarintCachedSizeFieldName(const FieldDescriptor* field,
bool split) {
return StrCat("_impl_.", split ? "_split_->" : "", "_",
FieldName(field), "_cached_byte_size_");
}
// Note: A lot of libraries detect Any protos based on Descriptor::full_name()
// while the two functions below use FileDescriptor::name(). In a sane world the
// two approaches should be equivalent. But if you are dealing with descriptors
// from untrusted sources, you might need to match semantics across libraries.
bool IsAnyMessage(const FileDescriptor* descriptor, const Options& options);
bool IsAnyMessage(const Descriptor* descriptor, const Options& options);
@ -680,6 +734,18 @@ inline std::string SimpleBaseClass(const Descriptor* desc,
return "";
}
// Returns true if this message has a _tracker_ field.
inline bool HasTracker(const Descriptor* desc, const Options& options) {
return options.field_listener_options.inject_field_listener_events &&
desc->file()->options().optimize_for() !=
google::protobuf::FileOptions::LITE_RUNTIME;
}
// Returns true if this message needs an Impl_ struct for it's data.
inline bool HasImplData(const Descriptor* desc, const Options& options) {
return !HasSimpleBaseClass(desc, options);
}
// Formatter is a functor class which acts as a closure around printer and
// the variable map. It's much like printer->Print except it supports both named
// variables that are substituted using a key value map and direct arguments. In
@ -711,7 +777,7 @@ inline std::string SimpleBaseClass(const Descriptor* desc,
// but consider using named variables. Named variables like $foo$, with some
// identifier foo, are looked up in the map. One additional feature is that
// spaces are accepted between the '$' delimiters, $ foo$ will
// substiture to " bar" if foo stands for "bar", but in case it's empty
// substitute to " bar" if foo stands for "bar", but in case it's empty
// will substitute to "". Hence, for example,
//
// Format(vars, "$dllexport $void fun();") -> "void fun();"
@ -955,12 +1021,39 @@ inline OneOfRangeImpl OneOfRange(const Descriptor* desc) { return {desc}; }
PROTOC_EXPORT std::string StripProto(const std::string& filename);
bool EnableMessageOwnedArena(const Descriptor* desc);
bool EnableMessageOwnedArena(const Descriptor* desc, const Options& options);
bool EnableMessageOwnedArenaTrial(const Descriptor* desc,
const Options& options);
bool ShouldVerify(const Descriptor* descriptor, const Options& options,
MessageSCCAnalyzer* scc_analyzer);
bool ShouldVerify(const FileDescriptor* file, const Options& options,
MessageSCCAnalyzer* scc_analyzer);
// Indicates whether to use predefined verify methods for a given message. If a
// message is "simple" and needs no special verification per field (e.g. message
// field, repeated packed, UTF8 string, etc.), we can use either VerifySimple or
// VerifySimpleAlwaysCheckInt32 methods as all verification can be done based on
// the wire type.
//
// Otherwise, we need "custom" verify methods tailored to a message to pass
// which field needs a special verification; i.e. InternalVerify.
enum class VerifySimpleType {
kSimpleInt32Never, // Use VerifySimple
kSimpleInt32Always, // Use VerifySimpleAlwaysCheckInt32
kCustom, // Use InternalVerify and check only for int32
kCustomInt32Never, // Use InternalVerify but never check for int32
kCustomInt32Always, // Use InternalVerify and always check for int32
};
// Returns VerifySimpleType if messages can be verified by predefined methods.
VerifySimpleType ShouldVerifySimple(const Descriptor* descriptor);
bool IsUtf8String(const FieldDescriptor* field);
bool HasMessageFieldOrExtension(const Descriptor* desc);
} // namespace cpp
} // namespace compiler
} // namespace protobuf

212
r5dev/thirdparty/protobuf/compiler/cpp/cpp_map_field.cc → r5dev/thirdparty/protobuf/compiler/cpp/map_field.cc vendored
View File

@ -28,12 +28,12 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <thirdparty/protobuf/compiler/cpp/cpp_map_field.h>
#include <thirdparty/protobuf/compiler/cpp/map_field.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_helpers.h>
#include <thirdparty/protobuf/io/printer.h>
#include <thirdparty/protobuf/wire_format.h>
#include <thirdparty/protobuf/stubs/strutil.h>
#include <thirdparty/protobuf/compiler/cpp/helpers.h>
namespace google {
@ -53,10 +53,8 @@ void SetMessageVariables(const FieldDescriptor* descriptor,
(*variables)["type"] = ClassName(descriptor->message_type(), false);
(*variables)["full_name"] = descriptor->full_name();
const FieldDescriptor* key =
descriptor->message_type()->FindFieldByName("key");
const FieldDescriptor* val =
descriptor->message_type()->FindFieldByName("value");
const FieldDescriptor* key = descriptor->message_type()->map_key();
const FieldDescriptor* val = descriptor->message_type()->map_value();
(*variables)["key_cpp"] = PrimitiveTypeName(options, key->cpp_type());
switch (val->cpp_type()) {
case FieldDescriptor::CPPTYPE_MESSAGE:
@ -128,7 +126,7 @@ void MapFieldGenerator::GenerateInlineAccessorDefinitions(
format(
"inline const ::$proto_ns$::Map< $key_cpp$, $val_cpp$ >&\n"
"$classname$::_internal_$name$() const {\n"
" return $name$_.GetMap();\n"
" return $field$.GetMap();\n"
"}\n"
"inline const ::$proto_ns$::Map< $key_cpp$, $val_cpp$ >&\n"
"$classname$::$name$() const {\n"
@ -138,7 +136,8 @@ void MapFieldGenerator::GenerateInlineAccessorDefinitions(
"}\n"
"inline ::$proto_ns$::Map< $key_cpp$, $val_cpp$ >*\n"
"$classname$::_internal_mutable_$name$() {\n"
" return $name$_.MutableMap();\n"
"$maybe_prepare_split_message$"
" return $field$.MutableMap();\n"
"}\n"
"inline ::$proto_ns$::Map< $key_cpp$, $val_cpp$ >*\n"
"$classname$::mutable_$name$() {\n"
@ -150,17 +149,17 @@ void MapFieldGenerator::GenerateInlineAccessorDefinitions(
void MapFieldGenerator::GenerateClearingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_.Clear();\n");
format("$field$.Clear();\n");
}
void MapFieldGenerator::GenerateMergingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_.MergeFrom(from.$name$_);\n");
format("_this->$field$.MergeFrom(from.$field$);\n");
}
void MapFieldGenerator::GenerateSwappingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_.InternalSwap(&other->$name$_);\n");
format("$field$.InternalSwap(&other->$field$);\n");
}
void MapFieldGenerator::GenerateCopyConstructorCode(
@ -169,35 +168,27 @@ void MapFieldGenerator::GenerateCopyConstructorCode(
GenerateMergingCode(printer);
}
static void GenerateSerializationLoop(const Formatter& format, bool string_key,
static void GenerateSerializationLoop(Formatter& format, bool string_key,
bool string_value,
bool is_deterministic) {
std::string ptr;
if (is_deterministic) {
format("for (size_type i = 0; i < n; i++) {\n");
ptr = string_key ? "items[static_cast<ptrdiff_t>(i)]"
: "items[static_cast<ptrdiff_t>(i)].second";
} else {
format(
"for (::$proto_ns$::Map< $key_cpp$, $val_cpp$ >::const_iterator\n"
" it = this->_internal_$name$().begin();\n"
" it != this->_internal_$name$().end(); ++it) {\n");
ptr = "it";
"for (const auto& entry : "
"::_pbi::MapSorter$1$<MapType>(map_field)) {\n",
(string_key ? "Ptr" : "Flat"));
} else {
format("for (const auto& entry : map_field) {\n");
}
format.Indent();
{
auto loop_scope = format.ScopedIndent();
format(
"target = WireHelper::InternalSerialize($number$, "
"entry.first, entry.second, target, stream);\n");
format(
"target = $map_classname$::Funcs::InternalSerialize($number$, "
"$1$->first, $1$->second, target, stream);\n",
ptr);
if (string_key || string_value) {
// ptr is either an actual pointer or an iterator, either way we can
// create a pointer by taking the address after de-referencing it.
format("Utf8Check::Check(&(*$1$));\n", ptr);
if (string_key || string_value) {
format("check_utf8(entry);\n");
}
}
format.Outdent();
format("}\n");
}
@ -206,77 +197,52 @@ void MapFieldGenerator::GenerateSerializeWithCachedSizesToArray(
Formatter format(printer, variables_);
format("if (!this->_internal_$name$().empty()) {\n");
format.Indent();
const FieldDescriptor* key_field =
descriptor_->message_type()->FindFieldByName("key");
const FieldDescriptor* value_field =
descriptor_->message_type()->FindFieldByName("value");
const FieldDescriptor* key_field = descriptor_->message_type()->map_key();
const FieldDescriptor* value_field = descriptor_->message_type()->map_value();
const bool string_key = key_field->type() == FieldDescriptor::TYPE_STRING;
const bool string_value = value_field->type() == FieldDescriptor::TYPE_STRING;
format(
"typedef ::$proto_ns$::Map< $key_cpp$, $val_cpp$ >::const_pointer\n"
" ConstPtr;\n");
if (string_key) {
format(
"typedef ConstPtr SortItem;\n"
"typedef ::$proto_ns$::internal::"
"CompareByDerefFirst<SortItem> Less;\n");
} else {
format(
"typedef ::$proto_ns$::internal::SortItem< $key_cpp$, ConstPtr > "
"SortItem;\n"
"typedef ::$proto_ns$::internal::CompareByFirstField<SortItem> "
"Less;\n");
}
"using MapType = ::_pb::Map<$key_cpp$, $val_cpp$>;\n"
"using WireHelper = $map_classname$::Funcs;\n"
"const auto& map_field = this->_internal_$name$();\n");
bool utf8_check = string_key || string_value;
if (utf8_check) {
format(
"struct Utf8Check {\n"
" static void Check(ConstPtr p) {\n"
// p may be unused when GetUtf8CheckMode evaluates to kNone,
// thus disabling the validation.
" (void)p;\n");
format.Indent();
format.Indent();
if (string_key) {
GenerateUtf8CheckCodeForString(
key_field, options_, false,
"p->first.data(), static_cast<int>(p->first.length()),\n", format);
format("auto check_utf8 = [](const MapType::value_type& entry) {\n");
{
auto check_scope = format.ScopedIndent();
// p may be unused when GetUtf8CheckMode evaluates to kNone,
// thus disabling the validation.
format("(void)entry;\n");
if (string_key) {
GenerateUtf8CheckCodeForString(
key_field, options_, false,
"entry.first.data(), static_cast<int>(entry.first.length()),\n",
format);
}
if (string_value) {
GenerateUtf8CheckCodeForString(
value_field, options_, false,
"entry.second.data(), static_cast<int>(entry.second.length()),\n",
format);
}
}
if (string_value) {
GenerateUtf8CheckCodeForString(
value_field, options_, false,
"p->second.data(), static_cast<int>(p->second.length()),\n", format);
}
format.Outdent();
format.Outdent();
format(
" }\n"
"};\n");
format("};\n");
}
format(
"\n"
"if (stream->IsSerializationDeterministic() &&\n"
" this->_internal_$name$().size() > 1) {\n"
" ::std::unique_ptr<SortItem[]> items(\n"
" new SortItem[this->_internal_$name$().size()]);\n"
" typedef ::$proto_ns$::Map< $key_cpp$, $val_cpp$ >::size_type "
"size_type;\n"
" size_type n = 0;\n"
" for (::$proto_ns$::Map< $key_cpp$, $val_cpp$ >::const_iterator\n"
" it = this->_internal_$name$().begin();\n"
" it != this->_internal_$name$().end(); ++it, ++n) {\n"
" items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);\n"
" }\n"
" ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());\n");
format.Indent();
GenerateSerializationLoop(format, string_key, string_value, true);
format.Outdent();
"if (stream->IsSerializationDeterministic() && "
"map_field.size() > 1) {\n");
{
auto deterministic_scope = format.ScopedIndent();
GenerateSerializationLoop(format, string_key, string_value, true);
}
format("} else {\n");
format.Indent();
GenerateSerializationLoop(format, string_key, string_value, false);
format.Outdent();
{
auto map_order_scope = format.ScopedIndent();
GenerateSerializationLoop(format, string_key, string_value, false);
}
format("}\n");
format.Outdent();
format("}\n");
@ -301,31 +267,69 @@ void MapFieldGenerator::GenerateIsInitialized(io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"if (!::$proto_ns$::internal::AllAreInitialized($name$_)) return "
"if (!::$proto_ns$::internal::AllAreInitialized($field$)) return "
"false;\n");
}
void MapFieldGenerator::GenerateConstinitInitializer(
void MapFieldGenerator::GenerateConstexprAggregateInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
if (HasDescriptorMethods(descriptor_->file(), options_)) {
format("$name$_(::$proto_ns$::internal::ConstantInitialized{})");
format("/*decltype($field$)*/{::_pbi::ConstantInitialized()}");
} else {
format("$name$_()");
format("/*decltype($field$)*/{}");
}
}
bool MapFieldGenerator::GenerateArenaDestructorCode(
void MapFieldGenerator::GenerateCopyAggregateInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
if (HasDescriptorMethods(descriptor_->file(), options_)) {
// _this is the object being destructed (we are inside a static method
// here).
format("_this->$name$_. ~MapField();\n");
return true;
} else {
return false;
// MapField has no move constructor, which prevents explicit aggregate
// initialization pre-C++17.
format("/*decltype($field$)*/{}");
}
void MapFieldGenerator::GenerateAggregateInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
if (ShouldSplit(descriptor_, options_)) {
format(
"/*decltype($classname$::Split::$name$_)*/"
"{::_pbi::ArenaInitialized(), arena}");
return;
}
// MapField has no move constructor.
format("/*decltype($field$)*/{::_pbi::ArenaInitialized(), arena}");
}
void MapFieldGenerator::GenerateDestructorCode(io::Printer* printer) const {
GOOGLE_CHECK(!IsFieldStripped(descriptor_, options_));
Formatter format(printer, variables_);
if (ShouldSplit(descriptor_, options_)) {
format("$cached_split_ptr$->$name$_.Destruct();\n");
format("$cached_split_ptr$->$name$_.~MapField$lite$();\n");
return;
}
format("$field$.Destruct();\n");
format("$field$.~MapField$lite$();\n");
}
void MapFieldGenerator::GenerateArenaDestructorCode(
io::Printer* printer) const {
if (NeedsArenaDestructor() == ArenaDtorNeeds::kNone) {
return;
}
Formatter format(printer, variables_);
// _this is the object being destructed (we are inside a static method here).
format("_this->$field$.Destruct();\n");
}
ArenaDtorNeeds MapFieldGenerator::NeedsArenaDestructor() const {
return HasDescriptorMethods(descriptor_->file(), options_)
? ArenaDtorNeeds::kRequired
: ArenaDtorNeeds::kNone;
}
} // namespace cpp

13
r5dev/thirdparty/protobuf/compiler/cpp/cpp_map_field.h → r5dev/thirdparty/protobuf/compiler/cpp/map_field.h vendored
View File

@ -34,8 +34,8 @@
#include <map>
#include <string>
#include <thirdparty/protobuf/compiler/cpp/cpp_helpers.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_message_field.h>
#include <thirdparty/protobuf/compiler/cpp/helpers.h>
#include <thirdparty/protobuf/compiler/cpp/message_field.h>
namespace google {
namespace protobuf {
@ -61,8 +61,13 @@ class MapFieldGenerator : public FieldGenerator {
io::Printer* printer) const override;
void GenerateByteSize(io::Printer* printer) const override;
void GenerateIsInitialized(io::Printer* printer) const override;
void GenerateConstinitInitializer(io::Printer* printer) const override;
bool GenerateArenaDestructorCode(io::Printer* printer) const override;
void GenerateConstexprAggregateInitializer(
io::Printer* printer) const override;
void GenerateCopyAggregateInitializer(io::Printer* printer) const override;
void GenerateAggregateInitializer(io::Printer* printer) const override;
void GenerateDestructorCode(io::Printer* printer) const override;
void GenerateArenaDestructorCode(io::Printer* printer) const override;
ArenaDtorNeeds NeedsArenaDestructor() const override;
private:
const bool has_required_fields_;

1750
r5dev/thirdparty/protobuf/compiler/cpp/cpp_message.cc → r5dev/thirdparty/protobuf/compiler/cpp/message.cc vendored
View File

File diff suppressed because it is too large Load Diff

49
r5dev/thirdparty/protobuf/compiler/cpp/cpp_message.h → r5dev/thirdparty/protobuf/compiler/cpp/message.h vendored
View File

@ -40,11 +40,11 @@
#include <set>
#include <string>
#include <thirdparty/protobuf/compiler/cpp/cpp_field.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_helpers.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_message_layout_helper.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_options.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_parse_function_generator.h>
#include <thirdparty/protobuf/compiler/cpp/field.h>
#include <thirdparty/protobuf/compiler/cpp/helpers.h>
#include <thirdparty/protobuf/compiler/cpp/message_layout_helper.h>
#include <thirdparty/protobuf/compiler/cpp/options.h>
#include <thirdparty/protobuf/compiler/cpp/parse_function_generator.h>
namespace google {
namespace protobuf {
@ -96,22 +96,10 @@ class MessageGenerator {
void GenerateFieldAccessorDeclarations(io::Printer* printer);
void GenerateFieldAccessorDefinitions(io::Printer* printer);
// Generate the table-driven parsing array. Returns the number of entries
// generated.
size_t GenerateParseOffsets(io::Printer* printer);
size_t GenerateParseAuxTable(io::Printer* printer);
// Generates a ParseTable entry. Returns whether the proto uses
// table-driven parsing.
bool GenerateParseTable(io::Printer* printer, size_t offset,
size_t aux_offset);
// Generate the field offsets array. Returns the a pair of the total number
// of entries generated and the index of the first has_bit entry.
std::pair<size_t, size_t> GenerateOffsets(io::Printer* printer);
void GenerateSchema(io::Printer* printer, int offset, int has_offset);
// For each field generates a table entry describing the field for the
// table driven serializer.
int GenerateFieldMetadata(io::Printer* printer);
// Generate constructors and destructor.
void GenerateStructors(io::Printer* printer);
@ -131,6 +119,9 @@ class MessageGenerator {
// default instance.
void GenerateConstexprConstructor(io::Printer* printer);
void GenerateCreateSplitMessage(io::Printer* printer);
void GenerateInitDefaultSplitInstance(io::Printer* printer);
// Generate standard Message methods.
void GenerateClear(io::Printer* printer);
void GenerateOneofClear(io::Printer* printer);
@ -141,7 +132,7 @@ class MessageGenerator {
void GenerateSerializeWithCachedSizesBodyShuffled(io::Printer* printer);
void GenerateByteSize(io::Printer* printer);
void GenerateMergeFrom(io::Printer* printer);
void GenerateClassSpecificMergeFrom(io::Printer* printer);
void GenerateClassSpecificMergeImpl(io::Printer* printer);
void GenerateCopyFrom(io::Printer* printer);
void GenerateSwap(io::Printer* printer);
void GenerateIsInitialized(io::Printer* printer);
@ -173,9 +164,20 @@ class MessageGenerator {
void GenerateFieldClear(const FieldDescriptor* field, bool is_inline,
Formatter format);
void GenerateConstructorBody(io::Printer* printer,
std::vector<bool> already_processed,
bool copy_constructor) const;
// Generates the body of the message's copy constructor.
void GenerateCopyConstructorBody(io::Printer* printer) const;
// Returns the level that this message needs ArenaDtor. If the message has
// a field that is not arena-exclusive, it needs an ArenaDtor
// (go/proto-destructor).
//
// - Returning kNone means we don't need to generate ArenaDtor.
// - Returning kOnDemand means we need to generate ArenaDtor, but don't need
// to register ArenaDtor at construction. Such as when the message's
// ArenaDtor code is only for destructing inlined string.
// - Returning kRequired means we meed to generate ArenaDtor and register it
// at construction.
ArenaDtorNeeds NeedsArenaDestructor() const;
size_t HasBitsSize() const;
size_t InlinedStringDonatedSize() const;
@ -200,7 +202,8 @@ class MessageGenerator {
int max_has_bit_index_;
// A map from field index to inlined_string index. For non-inlined-string
// fields, the element is -1.
// fields, the element is -1. If there is no inlined string in the message,
// this is empty.
std::vector<int> inlined_string_indices_;
// The count of inlined_string fields in the message.
int max_inlined_string_index_;
@ -209,8 +212,6 @@ class MessageGenerator {
std::vector<const ExtensionGenerator*> extension_generators_;
int num_required_fields_;
int num_weak_fields_;
// table_driven_ indicates the generated message uses table-driven parsing.
bool table_driven_;
std::unique_ptr<MessageLayoutHelper> message_layout_helper_;
std::unique_ptr<ParseFunctionGenerator> parse_function_generator_;

328
r5dev/thirdparty/protobuf/compiler/cpp/cpp_message_field.cc → r5dev/thirdparty/protobuf/compiler/cpp/message_field.cc vendored
View File

@ -32,9 +32,11 @@
// Based on original Protocol Buffers design by
// Sanjay Ghemawat, Jeff Dean, and others.
#include <thirdparty/protobuf/compiler/cpp/cpp_message_field.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_helpers.h>
#include <thirdparty/protobuf/compiler/cpp/message_field.h>
#include <thirdparty/protobuf/io/printer.h>
#include <thirdparty/protobuf/compiler/cpp/field.h>
#include <thirdparty/protobuf/compiler/cpp/helpers.h>
#include <thirdparty/protobuf/stubs/strutil.h>
@ -60,11 +62,16 @@ void SetMessageVariables(const FieldDescriptor* descriptor,
SetCommonFieldVariables(descriptor, variables, options);
(*variables)["type"] = FieldMessageTypeName(descriptor, options);
(*variables)["casted_member"] = ReinterpretCast(
(*variables)["type"] + "*", (*variables)["name"] + "_", implicit_weak);
(*variables)["type"] + "*", (*variables)["field"], implicit_weak);
(*variables)["casted_member_const"] =
ReinterpretCast("const " + (*variables)["type"] + "&",
"*" + (*variables)["field"], implicit_weak);
(*variables)["type_default_instance"] =
QualifiedDefaultInstanceName(descriptor->message_type(), options);
(*variables)["type_default_instance_ptr"] =
QualifiedDefaultInstancePtr(descriptor->message_type(), options);
(*variables)["type_default_instance_ptr"] = ReinterpretCast(
"const ::PROTOBUF_NAMESPACE_ID::MessageLite*",
QualifiedDefaultInstancePtr(descriptor->message_type(), options),
implicit_weak);
(*variables)["type_reference_function"] =
implicit_weak ? (" ::" + (*variables)["proto_ns"] +
"::internal::StrongReference(reinterpret_cast<const " +
@ -151,8 +158,7 @@ void MessageFieldGenerator::GenerateAccessorDeclarations(
}
void MessageFieldGenerator::GenerateNonInlineAccessorDefinitions(
io::Printer* printer) const {
}
io::Printer* printer) const {}
void MessageFieldGenerator::GenerateInlineAccessorDefinitions(
io::Printer* printer) const {
@ -173,17 +179,17 @@ void MessageFieldGenerator::GenerateInlineAccessorDefinitions(
format(
"inline void $classname$::unsafe_arena_set_allocated_$name$(\n"
" $type$* $name$) {\n"
"$maybe_prepare_split_message$"
// If we're not on an arena, free whatever we were holding before.
// (If we are on arena, we can just forget the earlier pointer.)
" if (GetArenaForAllocation() == nullptr) {\n"
" delete reinterpret_cast<::$proto_ns$::MessageLite*>($name$_);\n"
" delete reinterpret_cast<::$proto_ns$::MessageLite*>($field$);\n"
" }\n");
if (implicit_weak_field_) {
format(
" $name$_ = "
"reinterpret_cast<::$proto_ns$::MessageLite*>($name$);\n");
" $field$ = reinterpret_cast<::$proto_ns$::MessageLite*>($name$);\n");
} else {
format(" $name$_ = $name$;\n");
format(" $field$ = $name$;\n");
}
format(
" if ($name$) {\n"
@ -199,9 +205,10 @@ void MessageFieldGenerator::GenerateInlineAccessorDefinitions(
"inline $type$* $classname$::$release_name$() {\n"
"$type_reference_function$"
"$annotate_release$"
"$maybe_prepare_split_message$"
" $clear_hasbit$\n"
" $type$* temp = $casted_member$;\n"
" $name$_ = nullptr;\n"
" $field$ = nullptr;\n"
"#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE\n"
" auto* old = reinterpret_cast<::$proto_ns$::MessageLite*>(temp);\n"
" temp = ::$proto_ns$::internal::DuplicateIfNonNull(temp);\n"
@ -217,9 +224,10 @@ void MessageFieldGenerator::GenerateInlineAccessorDefinitions(
"$annotate_release$"
" // @@protoc_insertion_point(field_release:$full_name$)\n"
"$type_reference_function$"
"$maybe_prepare_split_message$"
" $clear_hasbit$\n"
" $type$* temp = $casted_member$;\n"
" $name$_ = nullptr;\n"
" $field$ = nullptr;\n"
" return temp;\n"
"}\n");
@ -227,18 +235,21 @@ void MessageFieldGenerator::GenerateInlineAccessorDefinitions(
"inline $type$* $classname$::_internal_mutable_$name$() {\n"
"$type_reference_function$"
" $set_hasbit$\n"
" if ($name$_ == nullptr) {\n"
" if ($field$ == nullptr) {\n"
" auto* p = CreateMaybeMessage<$type$>(GetArenaForAllocation());\n");
if (implicit_weak_field_) {
format(" $name$_ = reinterpret_cast<::$proto_ns$::MessageLite*>(p);\n");
format(" $field$ = reinterpret_cast<::$proto_ns$::MessageLite*>(p);\n");
} else {
format(" $name$_ = p;\n");
format(" $field$ = p;\n");
}
format(
" }\n"
" return $casted_member$;\n"
"}\n"
"inline $type$* $classname$::mutable_$name$() {\n"
// TODO(b/122856539): add tests to make sure all write accessors are able
// to prepare split message allocation.
"$maybe_prepare_split_message$"
" $type$* _msg = _internal_mutable_$name$();\n"
"$annotate_mutable$"
" // @@protoc_insertion_point(field_mutable:$full_name$)\n"
@ -250,12 +261,14 @@ void MessageFieldGenerator::GenerateInlineAccessorDefinitions(
format(
"inline void $classname$::set_allocated_$name$($type$* $name$) {\n"
" ::$proto_ns$::Arena* message_arena = GetArenaForAllocation();\n");
format(" if (message_arena == nullptr) {\n");
format(
"$maybe_prepare_split_message$"
" if (message_arena == nullptr) {\n");
if (IsCrossFileMessage(descriptor_)) {
format(
" delete reinterpret_cast< ::$proto_ns$::MessageLite*>($name$_);\n");
" delete reinterpret_cast< ::$proto_ns$::MessageLite*>($field$);\n");
} else {
format(" delete $name$_;\n");
format(" delete $field$;\n");
}
format(
" }\n"
@ -265,14 +278,13 @@ void MessageFieldGenerator::GenerateInlineAccessorDefinitions(
// isn't defined in this file.
format(
" ::$proto_ns$::Arena* submessage_arena =\n"
" ::$proto_ns$::Arena::InternalHelper<\n"
" ::$proto_ns$::MessageLite>::GetOwningArena(\n"
" ::$proto_ns$::Arena::InternalGetOwningArena(\n"
" reinterpret_cast<::$proto_ns$::MessageLite*>("
"$name$));\n");
} else {
format(
" ::$proto_ns$::Arena* submessage_arena =\n"
" ::$proto_ns$::Arena::InternalHelper<$type$>::GetOwningArena("
" ::$proto_ns$::Arena::InternalGetOwningArena("
"$name$);\n");
}
format(
@ -285,9 +297,9 @@ void MessageFieldGenerator::GenerateInlineAccessorDefinitions(
" $clear_hasbit$\n"
" }\n");
if (implicit_weak_field_) {
format(" $name$_ = reinterpret_cast<MessageLite*>($name$);\n");
format(" $field$ = reinterpret_cast<MessageLite*>($name$);\n");
} else {
format(" $name$_ = $name$;\n");
format(" $field$ = $name$;\n");
}
format(
"$annotate_set$"
@ -322,14 +334,10 @@ void MessageFieldGenerator::GenerateInternalAccessorDefinitions(
format(
"const ::$proto_ns$::MessageLite& $classname$::_Internal::$name$(\n"
" const $classname$* msg) {\n"
" if (msg->$name$_ != nullptr) {\n"
" return *msg->$name$_;\n"
" } else if ($type_default_instance_ptr$ != nullptr) {\n"
" return *reinterpret_cast<const ::$proto_ns$::MessageLite*>(\n"
" $type_default_instance_ptr$);\n"
" if (msg->$field$ != nullptr) {\n"
" return *msg->$field$;\n"
" } else {\n"
" return "
"*::$proto_ns$::internal::ImplicitWeakMessage::default_instance();\n"
" return *$type_default_instance_ptr$;\n"
" }\n"
"}\n");
format(
@ -338,20 +346,19 @@ void MessageFieldGenerator::GenerateInternalAccessorDefinitions(
if (HasHasbit(descriptor_)) {
format(" msg->$set_hasbit$\n");
}
if (descriptor_->real_containing_oneof() == nullptr) {
format(" if (msg->$field$ == nullptr) {\n");
} else {
format(
" if (!msg->_internal_has_$name$()) {\n"
" msg->clear_$oneof_name$();\n"
" msg->set_has_$name$();\n");
}
format(
" if (msg->$name$_ == nullptr) {\n"
" if ($type_default_instance_ptr$ == nullptr) {\n"
" msg->$name$_ = ::$proto_ns$::Arena::CreateMessage<\n"
" ::$proto_ns$::internal::ImplicitWeakMessage>(\n"
" msg->GetArenaForAllocation());\n"
" } else {\n"
" msg->$name$_ = \n"
" reinterpret_cast<const ::$proto_ns$::MessageLite*>(\n"
" $type_default_instance_ptr$)->New(\n"
" msg->GetArenaForAllocation());\n"
" }\n"
" msg->$field$ = $type_default_instance_ptr$->New(\n"
" msg->GetArenaForAllocation());\n"
" }\n"
" return msg->$name$_;\n"
" return msg->$field$;\n"
"}\n");
} else {
// This inline accessor directly returns member field and is used in
@ -360,7 +367,7 @@ void MessageFieldGenerator::GenerateInternalAccessorDefinitions(
format(
"const $type$&\n"
"$classname$::_Internal::$name$(const $classname$* msg) {\n"
" return *msg->$field_member$;\n"
" return *msg->$field$;\n"
"}\n");
}
}
@ -371,14 +378,14 @@ void MessageFieldGenerator::GenerateClearingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
if (!HasHasbit(descriptor_)) {
// If we don't have has-bits, message presence is indicated only by ptr !=
// NULL. Thus on clear, we need to delete the object.
// nullptr. Thus on clear, we need to delete the object.
format(
"if (GetArenaForAllocation() == nullptr && $name$_ != nullptr) {\n"
" delete $name$_;\n"
"if (GetArenaForAllocation() == nullptr && $field$ != nullptr) {\n"
" delete $field$;\n"
"}\n"
"$name$_ = nullptr;\n");
"$field$ = nullptr;\n");
} else {
format("if ($name$_ != nullptr) $name$_->Clear();\n");
format("if ($field$ != nullptr) $field$->Clear();\n");
}
}
@ -389,16 +396,16 @@ void MessageFieldGenerator::GenerateMessageClearingCode(
Formatter format(printer, variables_);
if (!HasHasbit(descriptor_)) {
// If we don't have has-bits, message presence is indicated only by ptr !=
// NULL. Thus on clear, we need to delete the object.
// nullptr. Thus on clear, we need to delete the object.
format(
"if (GetArenaForAllocation() == nullptr && $name$_ != nullptr) {\n"
" delete $name$_;\n"
"if (GetArenaForAllocation() == nullptr && $field$ != nullptr) {\n"
" delete $field$;\n"
"}\n"
"$name$_ = nullptr;\n");
"$field$ = nullptr;\n");
} else {
format(
"$DCHK$($name$_ != nullptr);\n"
"$name$_->Clear();\n");
"$DCHK$($field$ != nullptr);\n"
"$field$->Clear();\n");
}
}
@ -408,12 +415,12 @@ void MessageFieldGenerator::GenerateMergingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
if (implicit_weak_field_) {
format(
"_Internal::mutable_$name$(this)->CheckTypeAndMergeFrom(\n"
"_Internal::mutable_$name$(_this)->CheckTypeAndMergeFrom(\n"
" _Internal::$name$(&from));\n");
} else {
format(
"_internal_mutable_$name$()->$type$::MergeFrom(from._internal_$name$())"
";\n");
"_this->_internal_mutable_$name$()->$type$::MergeFrom(\n"
" from._internal_$name$());\n");
}
}
@ -421,7 +428,7 @@ void MessageFieldGenerator::GenerateSwappingCode(io::Printer* printer) const {
GOOGLE_CHECK(!IsFieldStripped(descriptor_, options_));
Formatter format(printer, variables_);
format("swap($name$_, other->$name$_);\n");
format("swap($field$, other->$field$);\n");
}
void MessageFieldGenerator::GenerateDestructorCode(io::Printer* printer) const {
@ -436,15 +443,11 @@ void MessageFieldGenerator::GenerateDestructorCode(io::Printer* printer) const {
// care when handling them.
format("if (this != internal_default_instance()) ");
}
format("delete $name$_;\n");
}
void MessageFieldGenerator::GenerateConstructorCode(
io::Printer* printer) const {
GOOGLE_CHECK(!IsFieldStripped(descriptor_, options_));
Formatter format(printer, variables_);
format("$name$_ = nullptr;\n");
if (ShouldSplit(descriptor_, options_)) {
format("delete $cached_split_ptr$->$name$_;\n");
return;
}
format("delete $field$;\n");
}
void MessageFieldGenerator::GenerateCopyConstructorCode(
@ -454,9 +457,7 @@ void MessageFieldGenerator::GenerateCopyConstructorCode(
Formatter format(printer, variables_);
format(
"if (from._internal_has_$name$()) {\n"
" $name$_ = new $type$(*from.$name$_);\n"
"} else {\n"
" $name$_ = nullptr;\n"
" _this->$field$ = new $type$(*from.$field$);\n"
"}\n");
}
@ -465,11 +466,18 @@ void MessageFieldGenerator::GenerateSerializeWithCachedSizesToArray(
GOOGLE_CHECK(!IsFieldStripped(descriptor_, options_));
Formatter format(printer, variables_);
format(
"target = stream->EnsureSpace(target);\n"
"target = ::$proto_ns$::internal::WireFormatLite::\n"
" InternalWrite$declared_type$(\n"
" $number$, _Internal::$name$(this), target, stream);\n");
if (descriptor_->type() == FieldDescriptor::TYPE_MESSAGE) {
format(
"target = ::$proto_ns$::internal::WireFormatLite::\n"
" InternalWrite$declared_type$($number$, _Internal::$name$(this),\n"
" _Internal::$name$(this).GetCachedSize(), target, stream);\n");
} else {
format(
"target = stream->EnsureSpace(target);\n"
"target = ::$proto_ns$::internal::WireFormatLite::\n"
" InternalWrite$declared_type$(\n"
" $number$, _Internal::$name$(this), target, stream);\n");
}
}
void MessageFieldGenerator::GenerateByteSize(io::Printer* printer) const {
@ -479,7 +487,7 @@ void MessageFieldGenerator::GenerateByteSize(io::Printer* printer) const {
format(
"total_size += $tag_size$ +\n"
" ::$proto_ns$::internal::WireFormatLite::$declared_type$Size(\n"
" *$field_member$);\n");
" *$field$);\n");
}
void MessageFieldGenerator::GenerateIsInitialized(io::Printer* printer) const {
@ -490,14 +498,30 @@ void MessageFieldGenerator::GenerateIsInitialized(io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"if (_internal_has_$name$()) {\n"
" if (!$name$_->IsInitialized()) return false;\n"
" if (!$field$->IsInitialized()) return false;\n"
"}\n");
}
void MessageFieldGenerator::GenerateConstinitInitializer(
void MessageFieldGenerator::GenerateConstexprAggregateInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_(nullptr)");
format("/*decltype($field$)*/nullptr");
}
void MessageFieldGenerator::GenerateCopyAggregateInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("decltype($field$){nullptr}");
}
void MessageFieldGenerator::GenerateAggregateInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
if (ShouldSplit(descriptor_, options_)) {
format("decltype(Impl_::Split::$name$_){nullptr}");
return;
}
format("decltype($field$){nullptr}");
}
// ===================================================================
@ -524,15 +548,13 @@ void MessageOneofFieldGenerator::GenerateNonInlineAccessorDefinitions(
// isn't defined in this file.
format(
" ::$proto_ns$::Arena* submessage_arena =\n"
" ::$proto_ns$::Arena::InternalHelper<\n"
" ::$proto_ns$::MessageLite>::GetOwningArena(\n"
" ::$proto_ns$::Arena::InternalGetOwningArena(\n"
" reinterpret_cast<::$proto_ns$::MessageLite*>("
"$name$));\n");
} else {
format(
" ::$proto_ns$::Arena* submessage_arena =\n"
" ::$proto_ns$::Arena::InternalHelper<"
"$type$>::GetOwningArena($name$);\n");
" ::$proto_ns$::Arena::InternalGetOwningArena($name$);\n");
}
format(
" if (message_arena != submessage_arena) {\n"
@ -540,7 +562,7 @@ void MessageOneofFieldGenerator::GenerateNonInlineAccessorDefinitions(
" message_arena, $name$, submessage_arena);\n"
" }\n"
" set_has_$name$();\n"
" $field_member$ = $name$;\n"
" $field$ = $name$;\n"
" }\n"
"$annotate_set$"
" // @@protoc_insertion_point(field_set_allocated:$full_name$)\n"
@ -554,13 +576,14 @@ void MessageOneofFieldGenerator::GenerateInlineAccessorDefinitions(
"inline $type$* $classname$::$release_name$() {\n"
"$annotate_release$"
" // @@protoc_insertion_point(field_release:$full_name$)\n"
"$type_reference_function$"
" if (_internal_has_$name$()) {\n"
" clear_has_$oneof_name$();\n"
" $type$* temp = $field_member$;\n"
" $type$* temp = $casted_member$;\n"
" if (GetArenaForAllocation() != nullptr) {\n"
" temp = ::$proto_ns$::internal::DuplicateIfNonNull(temp);\n"
" }\n"
" $field_member$ = nullptr;\n"
" $field$ = nullptr;\n"
" return temp;\n"
" } else {\n"
" return nullptr;\n"
@ -569,8 +592,9 @@ void MessageOneofFieldGenerator::GenerateInlineAccessorDefinitions(
format(
"inline const $type$& $classname$::_internal_$name$() const {\n"
"$type_reference_function$"
" return _internal_has_$name$()\n"
" ? *$field_member$\n"
" ? $casted_member_const$\n"
" : reinterpret_cast< $type$&>($type_default_instance$);\n"
"}\n"
"inline const $type$& $classname$::$name$() const {\n"
@ -582,10 +606,11 @@ void MessageOneofFieldGenerator::GenerateInlineAccessorDefinitions(
"$annotate_release$"
" // @@protoc_insertion_point(field_unsafe_arena_release"
":$full_name$)\n"
"$type_reference_function$"
" if (_internal_has_$name$()) {\n"
" clear_has_$oneof_name$();\n"
" $type$* temp = $field_member$;\n"
" $field_member$ = nullptr;\n"
" $type$* temp = $casted_member$;\n"
" $field$ = nullptr;\n"
" return temp;\n"
" } else {\n"
" return nullptr;\n"
@ -598,21 +623,38 @@ void MessageOneofFieldGenerator::GenerateInlineAccessorDefinitions(
// new value.
" clear_$oneof_name$();\n"
" if ($name$) {\n"
" set_has_$name$();\n"
" $field_member$ = $name$;\n"
" set_has_$name$();\n");
if (implicit_weak_field_) {
format(
" $field$ = "
"reinterpret_cast<::$proto_ns$::MessageLite*>($name$);\n");
} else {
format(" $field$ = $name$;\n");
}
format(
" }\n"
"$annotate_set$"
" // @@protoc_insertion_point(field_unsafe_arena_set_allocated:"
"$full_name$)\n"
"}\n"
"inline $type$* $classname$::_internal_mutable_$name$() {\n"
"$type_reference_function$"
" if (!_internal_has_$name$()) {\n"
" clear_$oneof_name$();\n"
" set_has_$name$();\n"
" $field_member$ = CreateMaybeMessage< $type$ "
">(GetArenaForAllocation());\n"
" set_has_$name$();\n");
if (implicit_weak_field_) {
format(
" $field$ = "
"reinterpret_cast<::$proto_ns$::MessageLite*>(CreateMaybeMessage< "
"$type$ >(GetArenaForAllocation()));\n");
} else {
format(
" $field$ = CreateMaybeMessage< $type$ "
">(GetArenaForAllocation());\n");
}
format(
" }\n"
" return $field_member$;\n"
" return $casted_member$;\n"
"}\n"
"inline $type$* $classname$::mutable_$name$() {\n"
" $type$* _msg = _internal_mutable_$name$();\n"
@ -629,7 +671,7 @@ void MessageOneofFieldGenerator::GenerateClearingCode(
Formatter format(printer, variables_);
format(
"if (GetArenaForAllocation() == nullptr) {\n"
" delete $field_member$;\n"
" delete $field$;\n"
"}\n");
}
@ -662,7 +704,7 @@ void MessageOneofFieldGenerator::GenerateIsInitialized(
Formatter format(printer, variables_);
format(
"if (_internal_has_$name$()) {\n"
" if (!$field_member$->IsInitialized()) return false;\n"
" if (!$field$->IsInitialized()) return false;\n"
"}\n");
}
@ -741,21 +783,21 @@ void RepeatedMessageFieldGenerator::GenerateInlineAccessorDefinitions(
// TODO(dlj): move insertion points
" // @@protoc_insertion_point(field_mutable:$full_name$)\n"
"$type_reference_function$"
" return $name$_$weak$.Mutable(index);\n"
" return $field$$weak$.Mutable(index);\n"
"}\n"
"inline ::$proto_ns$::RepeatedPtrField< $type$ >*\n"
"$classname$::mutable_$name$() {\n"
"$annotate_mutable_list$"
" // @@protoc_insertion_point(field_mutable_list:$full_name$)\n"
"$type_reference_function$"
" return &$name$_$weak$;\n"
" return &$field$$weak$;\n"
"}\n");
if (options_.safe_boundary_check) {
format(
"inline const $type$& $classname$::_internal_$name$(int index) const "
"{\n"
" return $name$_$weak$.InternalCheckedGet(index,\n"
" return $field$$weak$.InternalCheckedGet(index,\n"
" reinterpret_cast<const $type$&>($type_default_instance$));\n"
"}\n");
} else {
@ -763,7 +805,7 @@ void RepeatedMessageFieldGenerator::GenerateInlineAccessorDefinitions(
"inline const $type$& $classname$::_internal_$name$(int index) const "
"{\n"
"$type_reference_function$"
" return $name$_$weak$.Get(index);\n"
" return $field$$weak$.Get(index);\n"
"}\n");
}
@ -774,7 +816,7 @@ void RepeatedMessageFieldGenerator::GenerateInlineAccessorDefinitions(
" return _internal_$name$(index);\n"
"}\n"
"inline $type$* $classname$::_internal_add_$name$() {\n"
" return $name$_$weak$.Add();\n"
" return $field$$weak$.Add();\n"
"}\n"
"inline $type$* $classname$::add_$name$() {\n"
" $type$* _add = _internal_add_$name$();\n"
@ -789,7 +831,7 @@ void RepeatedMessageFieldGenerator::GenerateInlineAccessorDefinitions(
"$annotate_list$"
" // @@protoc_insertion_point(field_list:$full_name$)\n"
"$type_reference_function$"
" return $name$_$weak$;\n"
" return $field$$weak$;\n"
"}\n");
}
@ -798,7 +840,7 @@ void RepeatedMessageFieldGenerator::GenerateClearingCode(
GOOGLE_CHECK(!IsFieldStripped(descriptor_, options_));
Formatter format(printer, variables_);
format("$name$_.Clear();\n");
format("$field$.Clear();\n");
}
void RepeatedMessageFieldGenerator::GenerateMergingCode(
@ -806,7 +848,7 @@ void RepeatedMessageFieldGenerator::GenerateMergingCode(
GOOGLE_CHECK(!IsFieldStripped(descriptor_, options_));
Formatter format(printer, variables_);
format("$name$_.MergeFrom(from.$name$_);\n");
format("_this->$field$.MergeFrom(from.$field$);\n");
}
void RepeatedMessageFieldGenerator::GenerateSwappingCode(
@ -814,7 +856,7 @@ void RepeatedMessageFieldGenerator::GenerateSwappingCode(
GOOGLE_CHECK(!IsFieldStripped(descriptor_, options_));
Formatter format(printer, variables_);
format("$name$_.InternalSwap(&other->$name$_);\n");
format("$field$.InternalSwap(&other->$field$);\n");
}
void RepeatedMessageFieldGenerator::GenerateConstructorCode(
@ -822,6 +864,18 @@ void RepeatedMessageFieldGenerator::GenerateConstructorCode(
// Not needed for repeated fields.
}
void RepeatedMessageFieldGenerator::GenerateDestructorCode(
io::Printer* printer) const {
GOOGLE_CHECK(!IsFieldStripped(descriptor_, options_));
Formatter format(printer, variables_);
if (implicit_weak_field_) {
format("$field$.~WeakRepeatedPtrField();\n");
} else {
format("$field$.~RepeatedPtrField();\n");
}
}
void RepeatedMessageFieldGenerator::GenerateSerializeWithCachedSizesToArray(
io::Printer* printer) const {
GOOGLE_CHECK(!IsFieldStripped(descriptor_, options_));
@ -829,23 +883,41 @@ void RepeatedMessageFieldGenerator::GenerateSerializeWithCachedSizesToArray(
Formatter format(printer, variables_);
if (implicit_weak_field_) {
format(
"for (auto it = this->$name$_.pointer_begin(),\n"
" end = this->$name$_.pointer_end(); it < end; ++it) {\n"
" target = stream->EnsureSpace(target);\n"
" target = ::$proto_ns$::internal::WireFormatLite::\n"
" InternalWrite$declared_type$($number$, **it, target, stream);\n"
"}\n");
"for (auto it = this->$field$.pointer_begin(),\n"
" end = this->$field$.pointer_end(); it < end; ++it) {\n");
if (descriptor_->type() == FieldDescriptor::TYPE_MESSAGE) {
format(
" target = ::$proto_ns$::internal::WireFormatLite::\n"
" InternalWrite$declared_type$($number$, "
"**it, (**it).GetCachedSize(), target, stream);\n");
} else {
format(
" target = stream->EnsureSpace(target);\n"
" target = ::$proto_ns$::internal::WireFormatLite::\n"
" InternalWrite$declared_type$($number$, **it, target, "
"stream);\n");
}
format("}\n");
} else {
format(
"for (unsigned int i = 0,\n"
" n = static_cast<unsigned int>(this->_internal_$name$_size()); i < "
"n; i++) "
"{\n"
" target = stream->EnsureSpace(target);\n"
" target = ::$proto_ns$::internal::WireFormatLite::\n"
" InternalWrite$declared_type$($number$, "
"this->_internal_$name$(i), target, stream);\n"
"}\n");
"for (unsigned i = 0,\n"
" n = static_cast<unsigned>(this->_internal_$name$_size());"
" i < n; i++) {\n");
if (descriptor_->type() == FieldDescriptor::TYPE_MESSAGE) {
format(
" const auto& repfield = this->_internal_$name$(i);\n"
" target = ::$proto_ns$::internal::WireFormatLite::\n"
" InternalWrite$declared_type$($number$, "
"repfield, repfield.GetCachedSize(), target, stream);\n"
"}\n");
} else {
format(
" target = stream->EnsureSpace(target);\n"
" target = ::$proto_ns$::internal::WireFormatLite::\n"
" InternalWrite$declared_type$($number$, "
"this->_internal_$name$(i), target, stream);\n"
"}\n");
}
}
}
@ -856,7 +928,7 @@ void RepeatedMessageFieldGenerator::GenerateByteSize(
Formatter format(printer, variables_);
format(
"total_size += $tag_size$UL * this->_internal_$name$_size();\n"
"for (const auto& msg : this->$name$_) {\n"
"for (const auto& msg : this->$field$) {\n"
" total_size +=\n"
" ::$proto_ns$::internal::WireFormatLite::$declared_type$Size(msg);\n"
"}\n");
@ -871,21 +943,15 @@ void RepeatedMessageFieldGenerator::GenerateIsInitialized(
Formatter format(printer, variables_);
if (implicit_weak_field_) {
format(
"if (!::$proto_ns$::internal::AllAreInitializedWeak($name$_.weak))\n"
"if (!::$proto_ns$::internal::AllAreInitializedWeak($field$.weak))\n"
" return false;\n");
} else {
format(
"if (!::$proto_ns$::internal::AllAreInitialized($name$_))\n"
"if (!::$proto_ns$::internal::AllAreInitialized($field$))\n"
" return false;\n");
}
}
void RepeatedMessageFieldGenerator::GenerateConstinitInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_()");
}
} // namespace cpp
} // namespace compiler
} // namespace protobuf

14
r5dev/thirdparty/protobuf/compiler/cpp/cpp_message_field.h → r5dev/thirdparty/protobuf/compiler/cpp/message_field.h vendored
View File

@ -37,8 +37,9 @@
#include <map>
#include <string>
#include <thirdparty/protobuf/compiler/cpp/cpp_field.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_helpers.h>
#include <thirdparty/protobuf/compiler/cpp/field.h>
#include <thirdparty/protobuf/compiler/cpp/helpers.h>
namespace google {
namespace protobuf {
@ -66,13 +67,16 @@ class MessageFieldGenerator : public FieldGenerator {
void GenerateMergingCode(io::Printer* printer) const override;
void GenerateSwappingCode(io::Printer* printer) const override;
void GenerateDestructorCode(io::Printer* printer) const override;
void GenerateConstructorCode(io::Printer* printer) const override;
void GenerateConstructorCode(io::Printer* printer) const override {}
void GenerateCopyConstructorCode(io::Printer* printer) const override;
void GenerateSerializeWithCachedSizesToArray(
io::Printer* printer) const override;
void GenerateByteSize(io::Printer* printer) const override;
void GenerateIsInitialized(io::Printer* printer) const override;
void GenerateConstinitInitializer(io::Printer* printer) const override;
void GenerateConstexprAggregateInitializer(
io::Printer* printer) const override;
void GenerateAggregateInitializer(io::Printer* printer) const override;
void GenerateCopyAggregateInitializer(io::Printer* printer) const override;
protected:
const bool implicit_weak_field_;
@ -123,11 +127,11 @@ class RepeatedMessageFieldGenerator : public FieldGenerator {
void GenerateSwappingCode(io::Printer* printer) const override;
void GenerateConstructorCode(io::Printer* printer) const override;
void GenerateCopyConstructorCode(io::Printer* printer) const override {}
void GenerateDestructorCode(io::Printer* printer) const override;
void GenerateSerializeWithCachedSizesToArray(
io::Printer* printer) const override;
void GenerateByteSize(io::Printer* printer) const override;
void GenerateIsInitialized(io::Printer* printer) const override;
void GenerateConstinitInitializer(io::Printer* printer) const override;
private:
const bool implicit_weak_field_;

2
r5dev/thirdparty/protobuf/compiler/cpp/cpp_message_layout_helper.h → r5dev/thirdparty/protobuf/compiler/cpp/message_layout_helper.h vendored
View File

@ -35,8 +35,8 @@
#ifndef GOOGLE_PROTOBUF_COMPILER_CPP_MESSAGE_LAYOUT_HELPER_H__
#define GOOGLE_PROTOBUF_COMPILER_CPP_MESSAGE_LAYOUT_HELPER_H__
#include <thirdparty/protobuf/compiler/cpp/cpp_options.h>
#include <thirdparty/protobuf/descriptor.h>
#include <thirdparty/protobuf/compiler/cpp/options.h>
namespace google {
namespace protobuf {

272
r5dev/thirdparty/protobuf/compiler/cpp/message_size_unittest.cc vendored Normal file
View File

@ -0,0 +1,272 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <thirdparty/protobuf/unittest.pb.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <thirdparty/protobuf/descriptor.h>
namespace google {
namespace protobuf {
namespace compiler {
namespace cpp {
// Can't use an anonymous namespace here due to brokenness of Tru64 compiler.
namespace cpp_unittest {
#if !defined(GOOGLE_CHECK_MESSAGE_SIZE)
#define GOOGLE_CHECK_MESSAGE_SIZE(t, expected)
#endif
// Mock structures to lock down the size of messages in a platform-independent
// way. The commented sizes only apply when build with clang x86_64.
struct MockMessageBase {
virtual ~MockMessageBase() = default; // 8 bytes vtable
void* internal_metadata; // 8 bytes
};
GOOGLE_CHECK_MESSAGE_SIZE(MockMessageBase, 16);
struct MockZeroFieldsBase : public MockMessageBase {
int cached_size; // 4 bytes
// + 4 bytes padding
};
GOOGLE_CHECK_MESSAGE_SIZE(MockZeroFieldsBase, 24);
struct MockExtensionSet {
void* arena; // 8 bytes
int16_t capacity; // 4 bytes
int16_t size; // 4 bytes
void* data; // 8 bytes
};
GOOGLE_CHECK_MESSAGE_SIZE(MockExtensionSet, 24);
struct MockRepeatedPtrField {
void* arena; // 8 bytes
int current_size; // 4 bytes
int total_size; // 4 bytes
void* data; // 8 bytes
};
GOOGLE_CHECK_MESSAGE_SIZE(MockRepeatedPtrField, 24);
struct MockRepeatedField {
int current_size; // 4 bytes
int total_size; // 4 bytes
void* data; // 8 bytes
};
GOOGLE_CHECK_MESSAGE_SIZE(MockRepeatedField, 16);
TEST(GeneratedMessageTest, MockSizes) {
// Consistency checks -- if these fail, the tests below will definitely fail.
GOOGLE_CHECK_EQ(sizeof(MessageLite), sizeof(MockMessageBase));
GOOGLE_CHECK_EQ(sizeof(Message), sizeof(MockMessageBase));
GOOGLE_CHECK_EQ(sizeof(internal::ZeroFieldsBase), sizeof(MockZeroFieldsBase));
GOOGLE_CHECK_EQ(sizeof(internal::ExtensionSet), sizeof(MockExtensionSet));
GOOGLE_CHECK_EQ(sizeof(RepeatedPtrField<std::string>), sizeof(MockRepeatedPtrField));
GOOGLE_CHECK_EQ(sizeof(RepeatedField<int>), sizeof(MockRepeatedField));
}
TEST(GeneratedMessageTest, EmptyMessageSize) {
EXPECT_EQ(sizeof(protobuf_unittest::TestEmptyMessage),
sizeof(MockZeroFieldsBase));
}
TEST(GeneratedMessageTest, ReservedSize) {
EXPECT_EQ(sizeof(protobuf_unittest::TestReservedFields),
sizeof(MockZeroFieldsBase));
}
TEST(GeneratedMessageTest, EmptyMessageWithExtensionsSize) {
struct MockGenerated : public MockMessageBase { // 16 bytes
MockExtensionSet extensions; // 24 bytes
int cached_size; // 4 bytes
// + 4 bytes of padding
};
GOOGLE_CHECK_MESSAGE_SIZE(MockGenerated, 48);
EXPECT_EQ(sizeof(protobuf_unittest::TestEmptyMessageWithExtensions),
sizeof(MockGenerated));
}
TEST(GeneratedMessageTest, RecursiveMessageSize) {
struct MockGenerated : public MockMessageBase { // 16 bytes
int has_bits[1]; // 4 bytes
int cached_size; // 4 bytes
void* a; // 8 bytes
int32_t i; // 4 bytes
// + 4 bytes padding
};
GOOGLE_CHECK_MESSAGE_SIZE(MockGenerated, 40);
EXPECT_EQ(sizeof(protobuf_unittest::TestRecursiveMessage),
sizeof(MockGenerated));
}
TEST(GeneratedMessageTest, OneStringSize) {
struct MockGenerated : public MockMessageBase { // 16 bytes
int has_bits[1]; // 4 bytes
int cached_size; // 4 bytes
void* data; // 8 bytes
};
GOOGLE_CHECK_MESSAGE_SIZE(MockGenerated, 32);
EXPECT_EQ(sizeof(protobuf_unittest::OneString), sizeof(MockGenerated));
}
TEST(GeneratedMessageTest, MoreStringSize) {
struct MockGenerated : public MockMessageBase { // 16 bytes
int has_bits[1]; // 4 bytes
int cached_size; // 4 bytes
MockRepeatedPtrField data; // 24 bytes
};
GOOGLE_CHECK_MESSAGE_SIZE(MockGenerated, 48);
EXPECT_EQ(sizeof(protobuf_unittest::MoreString), sizeof(MockGenerated));
}
TEST(GeneratedMessageTest, Int32MessageSize) {
struct MockGenerated : public MockMessageBase { // 16 bytes
int has_bits[1]; // 4 bytes
int cached_size; // 4 bytes
int32_t data; // 4 bytes
// + 4 bytes padding
};
GOOGLE_CHECK_MESSAGE_SIZE(MockGenerated, 32);
EXPECT_EQ(sizeof(protobuf_unittest::Int32Message), sizeof(MockGenerated));
}
TEST(GeneratedMessageTest, Int64MessageSize) {
struct MockGenerated : public MockMessageBase { // 16 bytes
int has_bits[1]; // 4 bytes
int cached_size; // 4 bytes
int64_t data; // 8 bytes
};
GOOGLE_CHECK_MESSAGE_SIZE(MockGenerated, 32);
EXPECT_EQ(sizeof(protobuf_unittest::Int64Message), sizeof(MockGenerated));
}
TEST(GeneratedMessageTest, BoolMessageSize) {
struct MockGenerated : public MockMessageBase { // 16 bytes
int has_bits[1]; // 4 bytes
int cached_size; // 4 bytes
bool data; // 1 byte
// + 3 bytes padding
};
GOOGLE_CHECK_MESSAGE_SIZE(MockGenerated, 32);
EXPECT_EQ(sizeof(protobuf_unittest::BoolMessage), sizeof(MockGenerated));
}
TEST(GeneratedMessageTest, OneofSize) {
struct MockGenerated : public MockMessageBase { // 16 bytes
void* foo; // 8 bytes
int cached_size; // 4 bytes
uint32_t oneof_case[1]; // 4 bytes
};
GOOGLE_CHECK_MESSAGE_SIZE(MockGenerated, 32);
EXPECT_EQ(sizeof(protobuf_unittest::TestOneof), sizeof(MockGenerated));
}
TEST(GeneratedMessageTest, Oneof2Size) {
struct MockGenerated : public MockMessageBase { // 16 bytes
int has_bits[1]; // 4 bytes
int cached_size; // 4 bytes
void* baz_string; // 8 bytes
int32_t baz_int; // 4 bytes
// + 4 bytes padding
void* foo; // 8 bytes
void* bar; // 8 bytes
uint32_t oneof_case[2]; // 8 bytes
};
GOOGLE_CHECK_MESSAGE_SIZE(MockGenerated, 64);
EXPECT_EQ(sizeof(protobuf_unittest::TestOneof2), sizeof(MockGenerated));
}
TEST(GeneratedMessageTest, FieldOrderingsSize) {
struct MockGenerated : public MockMessageBase { // 16 bytes
int has_bits[1]; // 4 bytes
int cached_size; // 4 bytes
MockExtensionSet extensions; // 24 bytes
void* my_string; // 8 bytes
void* optional_nested_message; // 8 bytes
int64_t my_int; // 8 bytes
float my_float; // 4 bytes
// + 4 bytes of padding
};
GOOGLE_CHECK_MESSAGE_SIZE(MockGenerated, 80);
EXPECT_EQ(sizeof(protobuf_unittest::TestFieldOrderings), sizeof(MockGenerated));
}
TEST(GeneratedMessageTest, TestMessageSize) {
// We expect the message to contain (not in this order):
struct MockGenerated : public MockMessageBase { // 16 bytes
int has_bits[1]; // 4 bytes
int cached_size; // 4 bytes
void* m4; // 8 bytes
int64_t m2; // 8 bytes
bool m1; // 1 bytes
bool m3; // 1 bytes
// + 2 bytes padding
int m5; // 4 bytes
int64_t m6; // 8 bytes
};
GOOGLE_CHECK_MESSAGE_SIZE(MockGenerated, 56);
EXPECT_EQ(sizeof(protobuf_unittest::TestMessageSize), sizeof(MockGenerated));
}
TEST(GeneratedMessageTest, PackedTypesSize) {
struct MockGenerated : public MockMessageBase { // 16 bytes
MockRepeatedField packed_int32; // 16 bytes
int packed_int32_cached_byte_size; // 4 bytes + 4 bytes padding
MockRepeatedField packed_int64; // 16 bytes
int packed_int64_cached_byte_size; // 4 bytes + 4 bytes padding
MockRepeatedField packed_uint32; // 16 bytes
int packed_uint32_cached_byte_size; // 4 bytes + 4 bytes padding
MockRepeatedField packed_uint64; // 16 bytes
int packed_uint64_cached_byte_size; // 4 bytes + 4 bytes padding
MockRepeatedField packed_sint32; // 16 bytes
int packed_sint32_cached_byte_size; // 4 bytes + 4 bytes padding
MockRepeatedField packed_sint64; // 16 bytes
int packed_sint64_cached_byte_size; // 4 bytes + 4 bytes padding
MockRepeatedField packed_fixed32; // 16 bytes
MockRepeatedField packed_fixed64; // 16 bytes
MockRepeatedField packed_sfixed32; // 16 bytes
MockRepeatedField packed_sfixed64; // 16 bytes
MockRepeatedField packed_float; // 16 bytes
MockRepeatedField packed_double; // 16 bytes
MockRepeatedField packed_bool; // 16 bytes
MockRepeatedField packed_enum; // 16 bytes
int packed_enum_cached_byte_size; // 4 bytes
int cached_size; // 4 bytes
};
GOOGLE_CHECK_MESSAGE_SIZE(MockGenerated, 16 * 15 + 8 * 6 + 8);
EXPECT_EQ(sizeof(protobuf_unittest::TestPackedTypes), sizeof(MockGenerated));
}
} // namespace cpp_unittest
} // namespace cpp
} // namespace compiler
} // namespace protobuf
} // namespace google

28
r5dev/thirdparty/protobuf/compiler/cpp/metadata_test.cc vendored
View File

@ -32,13 +32,13 @@
#include <thirdparty/protobuf/testing/file.h>
#include <thirdparty/protobuf/testing/file.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_helpers.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_generator.h>
#include <thirdparty/protobuf/compiler/annotation_test_util.h>
#include <thirdparty/protobuf/compiler/cpp/generator.h>
#include <thirdparty/protobuf/compiler/command_line_interface.h>
#include <thirdparty/protobuf/descriptor.pb.h>
#include <thirdparty/protobuf/testing/googletest.h>
#include <gtest/gtest.h>
#include <thirdparty/protobuf/compiler/annotation_test_util.h>
#include <thirdparty/protobuf/compiler/cpp/helpers.h>
namespace google {
namespace protobuf {
@ -76,12 +76,12 @@ class CppMetadataTest : public ::testing::Test {
std::string output_base = TestTempDir() + "/" + StripProto(filename);
if (pb_cc != NULL) {
if (pb_cc != nullptr) {
GOOGLE_CHECK_OK(
File::GetContents(output_base + ".pb.cc", pb_cc, true));
}
if (pb_h != NULL && pb_h_info != NULL) {
if (pb_h != nullptr && pb_h_info != nullptr) {
GOOGLE_CHECK_OK(
File::GetContents(output_base + ".pb.h", pb_h, true));
if (!atu::DecodeMetadata(output_base + ".pb.h.meta", pb_h_info)) {
@ -89,7 +89,7 @@ class CppMetadataTest : public ::testing::Test {
}
}
if (proto_h != NULL && proto_h_info != NULL) {
if (proto_h != nullptr && proto_h_info != nullptr) {
GOOGLE_CHECK_OK(File::GetContents(output_base + ".proto.h", proto_h,
true));
if (!atu::DecodeMetadata(output_base + ".proto.h.meta", proto_h_info)) {
@ -112,15 +112,15 @@ TEST_F(CppMetadataTest, CapturesEnumNames) {
GeneratedCodeInfo info;
std::string pb_h;
atu::AddFile("test.proto", kSmallTestFile);
EXPECT_TRUE(
CaptureMetadata("test.proto", &file, &pb_h, &info, NULL, NULL, NULL));
EXPECT_TRUE(CaptureMetadata("test.proto", &file, &pb_h, &info, nullptr,
nullptr, nullptr));
EXPECT_EQ("Enum", file.enum_type(0).name());
std::vector<int> enum_path;
enum_path.push_back(FileDescriptorProto::kEnumTypeFieldNumber);
enum_path.push_back(0);
const GeneratedCodeInfo::Annotation* enum_annotation =
atu::FindAnnotationOnPath(info, "test.proto", enum_path);
EXPECT_TRUE(NULL != enum_annotation);
EXPECT_TRUE(nullptr != enum_annotation);
EXPECT_TRUE(atu::AnnotationMatchesSubstring(pb_h, enum_annotation, "Enum"));
}
@ -129,8 +129,8 @@ TEST_F(CppMetadataTest, AddsPragma) {
GeneratedCodeInfo info;
std::string pb_h;
atu::AddFile("test.proto", kSmallTestFile);
EXPECT_TRUE(
CaptureMetadata("test.proto", &file, &pb_h, &info, NULL, NULL, NULL));
EXPECT_TRUE(CaptureMetadata("test.proto", &file, &pb_h, &info, nullptr,
nullptr, nullptr));
EXPECT_TRUE(pb_h.find("#ifdef guard_name") != std::string::npos);
EXPECT_TRUE(pb_h.find("#pragma pragma_name \"test.pb.h.meta\"") !=
std::string::npos);
@ -141,15 +141,15 @@ TEST_F(CppMetadataTest, CapturesMessageNames) {
GeneratedCodeInfo info;
std::string pb_h;
atu::AddFile("test.proto", kSmallTestFile);
EXPECT_TRUE(
CaptureMetadata("test.proto", &file, &pb_h, &info, NULL, NULL, NULL));
EXPECT_TRUE(CaptureMetadata("test.proto", &file, &pb_h, &info, nullptr,
nullptr, nullptr));
EXPECT_EQ("Message", file.message_type(0).name());
std::vector<int> message_path;
message_path.push_back(FileDescriptorProto::kMessageTypeFieldNumber);
message_path.push_back(0);
const GeneratedCodeInfo::Annotation* message_annotation =
atu::FindAnnotationOnPath(info, "test.proto", message_path);
EXPECT_TRUE(NULL != message_annotation);
EXPECT_TRUE(nullptr != message_annotation);
EXPECT_TRUE(
atu::AnnotationMatchesSubstring(pb_h, message_annotation, "Message"));
}

0
r5dev/thirdparty/protobuf/compiler/cpp/cpp_move_unittest.cc → r5dev/thirdparty/protobuf/compiler/cpp/move_unittest.cc vendored
View File

11
r5dev/thirdparty/protobuf/compiler/cpp/cpp_names.h → r5dev/thirdparty/protobuf/compiler/cpp/names.h vendored
View File

@ -33,6 +33,7 @@
#include <string>
// Must be included last.
#include <thirdparty/protobuf/port_def.inc>
namespace google {
@ -50,9 +51,9 @@ namespace cpp {
//
// For example, if you had:
// package foo.bar;
// message Baz { message Qux {} }
// message Baz { message Moo {} }
// Then the non-qualified version would be:
// Baz_Qux
// Baz_Moo
std::string ClassName(const Descriptor* descriptor);
std::string ClassName(const EnumDescriptor* enum_descriptor);
@ -60,9 +61,9 @@ std::string ClassName(const EnumDescriptor* enum_descriptor);
//
// For example, if you had:
// package foo.bar;
// message Baz { message Qux {} }
// Then the qualified ClassName for Qux would be:
// ::foo::bar::Baz_Qux
// message Baz { message Moo {} }
// Then the qualified ClassName for Moo would be:
// ::foo::bar::Baz_Moo
std::string QualifiedClassName(const Descriptor* d);
std::string QualifiedClassName(const EnumDescriptor* d);
std::string QualifiedExtensionName(const FieldDescriptor* d);

42
r5dev/thirdparty/protobuf/compiler/cpp/cpp_options.h → r5dev/thirdparty/protobuf/compiler/cpp/options.h vendored
View File

@ -57,34 +57,40 @@ struct FieldListenerOptions {
// Generator options (see generator.cc for a description of each):
struct Options {
const AccessInfoMap* access_info_map = nullptr;
std::string dllexport_decl;
bool safe_boundary_check = false;
bool proto_h = false;
bool transitive_pb_h = true;
bool annotate_headers = false;
EnforceOptimizeMode enforce_mode = EnforceOptimizeMode::kNoEnforcement;
bool table_driven_parsing = false;
bool table_driven_serialization = false;
bool lite_implicit_weak_fields = false;
bool bootstrap = false;
bool opensource_runtime = false;
bool annotate_accessor = false;
bool unused_field_stripping = false;
bool profile_driven_inline_string = true;
bool force_inline_string = false;
std::string runtime_include_base;
int num_cc_files = 0;
std::string annotation_pragma_name;
std::string annotation_guard_name;
const AccessInfoMap* access_info_map = nullptr;
FieldListenerOptions field_listener_options;
EnforceOptimizeMode enforce_mode = EnforceOptimizeMode::kNoEnforcement;
enum {
kTCTableNever,
kTCTableGuarded,
kTCTableAlways
} tctable_mode = kTCTableNever;
FieldListenerOptions field_listener_options;
bool eagerly_verified_lazy = false;
int num_cc_files = 0;
bool safe_boundary_check = false;
bool proto_h = false;
bool transitive_pb_h = true;
bool annotate_headers = false;
bool lite_implicit_weak_fields = false;
bool bootstrap = false;
bool opensource_runtime = false;
bool annotate_accessor = false;
bool unused_field_stripping = false;
bool unverified_lazy_message_sets = false;
bool unverified_lazy = false;
bool profile_driven_inline_string = true;
bool message_owned_arena_trial = false;
bool force_split = false;
#ifdef PROTOBUF_STABLE_EXPERIMENTS
bool force_eagerly_verified_lazy = true;
bool force_inline_string = true;
#else // PROTOBUF_STABLE_EXPERIMENTS
bool force_eagerly_verified_lazy = false;
bool force_inline_string = false;
#endif // !PROTOBUF_STABLE_EXPERIMENTS
};
} // namespace cpp

12
r5dev/thirdparty/protobuf/compiler/cpp/cpp_padding_optimizer.cc → r5dev/thirdparty/protobuf/compiler/cpp/padding_optimizer.cc vendored
View File

@ -28,9 +28,9 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <thirdparty/protobuf/compiler/cpp/cpp_padding_optimizer.h>
#include <thirdparty/protobuf/compiler/cpp/padding_optimizer.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_helpers.h>
#include <thirdparty/protobuf/compiler/cpp/helpers.h>
namespace google {
namespace protobuf {
@ -47,7 +47,7 @@ class FieldGroup {
FieldGroup() : preferred_location_(0) {}
// A group with a single field.
FieldGroup(float preferred_location, const FieldDescriptor* field)
FieldGroup(double preferred_location, const FieldDescriptor* field)
: preferred_location_(preferred_location), fields_(1, field) {}
// Append the fields in 'other' to this group.
@ -63,7 +63,7 @@ class FieldGroup {
fields_.insert(fields_.end(), other.fields_.begin(), other.fields_.end());
}
void SetPreferredLocation(float location) { preferred_location_ = location; }
void SetPreferredLocation(double location) { preferred_location_ = location; }
const std::vector<const FieldDescriptor*>& fields() const { return fields_; }
// FieldGroup objects sort by their preferred location.
@ -77,7 +77,7 @@ class FieldGroup {
// field in this group in the original ordering of fields. This is very
// approximate, but should put this group close to where its member fields
// originally went.
float preferred_location_;
double preferred_location_;
std::vector<const FieldDescriptor*> fields_;
// We rely on the default copy constructor and operator= so this type can be
// used in a vector.
@ -203,7 +203,7 @@ void PaddingOptimizer::OptimizeLayout(
field_group.SetPreferredLocation(-1);
} else {
// Move incomplete 4-byte block to the end.
field_group.SetPreferredLocation(fields->size() + 1);
field_group.SetPreferredLocation(double{FieldDescriptor::kMaxNumber});
}
}
aligned_to_8[f].push_back(field_group);

2
r5dev/thirdparty/protobuf/compiler/cpp/cpp_padding_optimizer.h → r5dev/thirdparty/protobuf/compiler/cpp/padding_optimizer.h vendored
View File

@ -35,7 +35,7 @@
#ifndef GOOGLE_PROTOBUF_COMPILER_CPP_PADDING_OPTIMIZER_H__
#define GOOGLE_PROTOBUF_COMPILER_CPP_PADDING_OPTIMIZER_H__
#include <thirdparty/protobuf/compiler/cpp/cpp_message_layout_helper.h>
#include <thirdparty/protobuf/compiler/cpp/message_layout_helper.h>
namespace google {
namespace protobuf {

1725
r5dev/thirdparty/protobuf/compiler/cpp/parse_function_generator.cc vendored Normal file
View File

File diff suppressed because it is too large Load Diff

93
r5dev/thirdparty/protobuf/compiler/cpp/cpp_parse_function_generator.h → r5dev/thirdparty/protobuf/compiler/cpp/parse_function_generator.h vendored
View File

@ -35,12 +35,11 @@
#include <string>
#include <vector>
#include <thirdparty/protobuf/compiler/cpp/cpp_helpers.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_options.h>
#include <thirdparty/protobuf/io/printer.h>
#include <thirdparty/protobuf/descriptor.h>
#include <thirdparty/protobuf/generated_message_tctable_decl.h>
#include <thirdparty/protobuf/wire_format_lite.h>
#include <thirdparty/protobuf/compiler/cpp/helpers.h>
#include <thirdparty/protobuf/compiler/cpp/options.h>
namespace google {
namespace protobuf {
@ -50,18 +49,36 @@ namespace cpp {
// Helper class for generating tailcall parsing functions.
struct TailCallTableInfo {
TailCallTableInfo(const Descriptor* descriptor, const Options& options,
const std::vector<const FieldDescriptor*>& ordered_fields,
const std::vector<int>& has_bit_indices,
const std::vector<int>& inlined_string_indices,
MessageSCCAnalyzer* scc_analyzer);
// Information to generate field entries.
struct FieldInfo {
const FieldDescriptor* field;
google::protobuf::internal::TcFieldData bits;
std::string func_name;
};
// Fields parsed by the table fast-path.
std::vector<FieldInfo> fast_path_fields;
// Fields parsed by slow-path fallback.
struct FastFieldInfo {
std::string func_name;
const FieldDescriptor* field;
uint16_t coded_tag;
uint8_t hasbit_idx;
uint8_t aux_idx;
};
std::vector<FastFieldInfo> fast_path_fields;
// Fields parsed by mini parsing routines.
struct FieldEntryInfo {
const FieldDescriptor* field;
int hasbit_idx;
int inlined_string_idx;
uint16_t aux_idx;
// True for enums entirely covered by the start/length fields of FieldAux:
bool is_enum_range;
};
std::vector<FieldEntryInfo> field_entries;
std::vector<std::string> aux_entries;
// Fields parsed by generated fallback function.
std::vector<const FieldDescriptor*> fallback_fields;
// Table size.
int table_size_log2;
// Mask for has-bits of required fields.
@ -110,15 +127,15 @@ class ParseFunctionGenerator {
// Generates a fallback function for tailcall table-based parsing.
void GenerateTailcallFallbackFunction(Formatter& format);
// Generates functions for parsing this message as a field.
void GenerateTailcallFieldParseFunctions(Formatter& format);
// Generates a looping `_InternalParse` function.
void GenerateLoopingParseFunction(Formatter& format);
// Generates the tail-call table definition.
void GenerateTailCallTable(Formatter& format);
void GenerateFastFieldEntries(Formatter& format, const std::string& fallback);
void GenerateFastFieldEntries(Formatter& format);
void GenerateFieldEntries(Formatter& format);
int CalculateFieldNamesSize() const;
void GenerateFieldNames(Formatter& format);
// Generates parsing code for an `ArenaString` field.
void GenerateArenaString(Formatter& format, const FieldDescriptor* field);
@ -139,12 +156,11 @@ class ParseFunctionGenerator {
// Generates code to parse the next field from the input stream.
void GenerateParseIterationBody(
Formatter& format, const Descriptor* descriptor,
const std::vector<const FieldDescriptor*>& ordered_fields);
const std::vector<const FieldDescriptor*>& fields);
// Generates a `switch` statement to parse each of `ordered_fields`.
void GenerateFieldSwitch(
Formatter& format,
const std::vector<const FieldDescriptor*>& ordered_fields);
// Generates a `switch` statement to parse each of `fields`.
void GenerateFieldSwitch(Formatter& format,
const std::vector<const FieldDescriptor*>& fields);
const Descriptor* descriptor_;
MessageSCCAnalyzer* scc_analyzer_;
@ -152,45 +168,10 @@ class ParseFunctionGenerator {
std::map<std::string, std::string> variables_;
std::unique_ptr<TailCallTableInfo> tc_table_info_;
std::vector<int> inlined_string_indices_;
const std::vector<const FieldDescriptor*> ordered_fields_;
int num_hasbits_;
};
enum class ParseCardinality {
kSingular,
kOneof,
kRepeated,
kPacked,
};
// TypeFormat defines parsing types, which encapsulates the expected wire
// format, conversion or validation, and the in-memory layout.
enum class TypeFormat {
// Fixed types:
kFixed64, // fixed64, sfixed64, double
kFixed32, // fixed32, sfixed32, float
// Varint types:
kVar64, // int64, uint64
kVar32, // int32, uint32
kSInt64, // sint64
kSInt32, // sint32
kBool, // bool
// Length-delimited types:
kBytes, // bytes
kString, // string (proto3/UTF-8 strict)
kStringValidateOnly, // string (proto2/UTF-8 validate only)
};
// Returns the name of a field parser function.
//
// These are out-of-line functions generated by
// parse_function_inc_generator_main.
std::string GetTailCallFieldHandlerName(ParseCardinality card,
TypeFormat type_format,
int tag_length_bytes,
const Options& options);
} // namespace cpp
} // namespace compiler
} // namespace protobuf

11
r5dev/thirdparty/protobuf/compiler/cpp/cpp_plugin_unittest.cc → r5dev/thirdparty/protobuf/compiler/cpp/plugin_unittest.cc vendored
View File

@ -38,7 +38,7 @@
#include <thirdparty/protobuf/testing/file.h>
#include <thirdparty/protobuf/testing/file.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_generator.h>
#include <thirdparty/protobuf/compiler/cpp/generator.h>
#include <thirdparty/protobuf/compiler/command_line_interface.h>
#include <thirdparty/protobuf/io/printer.h>
#include <thirdparty/protobuf/io/zero_copy_stream.h>
@ -54,11 +54,10 @@ namespace {
class TestGenerator : public CodeGenerator {
public:
TestGenerator() {}
~TestGenerator() {}
~TestGenerator() override {}
virtual bool Generate(const FileDescriptor* file,
const std::string& parameter, GeneratorContext* context,
std::string* error) const {
bool Generate(const FileDescriptor* file, const std::string& parameter,
GeneratorContext* context, std::string* error) const override {
TryInsert("test.pb.h", "includes", context);
TryInsert("test.pb.h", "namespace_scope", context);
TryInsert("test.pb.h", "global_scope", context);
@ -199,7 +198,7 @@ TEST(CppPluginTest, PluginTest) {
" ctype = CORD\n"
" ];\n"
"\n"
" oneof Qux {\n"
" oneof Moo {\n"
" int64 oneOfInt = 20;\n"
" string oneOfString = 21;\n"
" Baz oneOfMessage = 22;\n"

136
r5dev/thirdparty/protobuf/compiler/cpp/cpp_primitive_field.cc → r5dev/thirdparty/protobuf/compiler/cpp/primitive_field.cc vendored
View File

@ -32,12 +32,12 @@
// Based on original Protocol Buffers design by
// Sanjay Ghemawat, Jeff Dean, and others.
#include <thirdparty/protobuf/compiler/cpp/cpp_primitive_field.h>
#include <thirdparty/protobuf/compiler/cpp/primitive_field.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_helpers.h>
#include <thirdparty/protobuf/io/printer.h>
#include <thirdparty/protobuf/wire_format.h>
#include <thirdparty/protobuf/stubs/strutil.h>
#include <thirdparty/protobuf/compiler/cpp/helpers.h>
namespace google {
namespace protobuf {
@ -104,6 +104,10 @@ void SetPrimitiveVariables(const FieldDescriptor* descriptor,
SetCommonFieldVariables(descriptor, variables, options);
(*variables)["type"] = PrimitiveTypeName(options, descriptor->cpp_type());
(*variables)["default"] = DefaultValue(options, descriptor);
(*variables)["cached_byte_size_name"] = MakeVarintCachedSizeName(descriptor);
bool cold = ShouldSplit(descriptor, options);
(*variables)["cached_byte_size_field"] =
MakeVarintCachedSizeFieldName(descriptor, cold);
(*variables)["tag"] = StrCat(internal::WireFormat::MakeTag(descriptor));
int fixed_size = FixedSize(descriptor->type());
if (fixed_size != -1) {
@ -150,7 +154,7 @@ void PrimitiveFieldGenerator::GenerateInlineAccessorDefinitions(
Formatter format(printer, variables_);
format(
"inline $type$ $classname$::_internal_$name$() const {\n"
" return $name$_;\n"
" return $field$;\n"
"}\n"
"inline $type$ $classname$::$name$() const {\n"
"$annotate_get$"
@ -159,9 +163,10 @@ void PrimitiveFieldGenerator::GenerateInlineAccessorDefinitions(
"}\n"
"inline void $classname$::_internal_set_$name$($type$ value) {\n"
" $set_hasbit$\n"
" $name$_ = value;\n"
" $field$ = value;\n"
"}\n"
"inline void $classname$::set_$name$($type$ value) {\n"
"$maybe_prepare_split_message$"
" _internal_set_$name$(value);\n"
"$annotate_set$"
" // @@protoc_insertion_point(field_set:$full_name$)\n"
@ -170,29 +175,23 @@ void PrimitiveFieldGenerator::GenerateInlineAccessorDefinitions(
void PrimitiveFieldGenerator::GenerateClearingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_ = $default$;\n");
format("$field$ = $default$;\n");
}
void PrimitiveFieldGenerator::GenerateMergingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
format("_internal_set_$name$(from._internal_$name$());\n");
format("_this->_internal_set_$name$(from._internal_$name$());\n");
}
void PrimitiveFieldGenerator::GenerateSwappingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
format("swap($name$_, other->$name$_);\n");
}
void PrimitiveFieldGenerator::GenerateConstructorCode(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_ = $default$;\n");
format("swap($field$, other->$field$);\n");
}
void PrimitiveFieldGenerator::GenerateCopyConstructorCode(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_ = from.$name$_;\n");
format("_this->$field$ = from.$field$;\n");
}
void PrimitiveFieldGenerator::GenerateSerializeWithCachedSizesToArray(
@ -201,7 +200,7 @@ void PrimitiveFieldGenerator::GenerateSerializeWithCachedSizesToArray(
format(
"target = stream->EnsureSpace(target);\n"
"target = "
"::$proto_ns$::internal::WireFormatLite::Write$declared_type$ToArray("
"::_pbi::WireFormatLite::Write$declared_type$ToArray("
"$number$, this->_internal_$name$(), target);\n");
}
@ -214,12 +213,12 @@ void PrimitiveFieldGenerator::GenerateByteSize(io::Printer* printer) const {
// Adding one is very common and it turns out it can be done for
// free inside of WireFormatLite, so we can save an instruction here.
format(
"total_size += ::$proto_ns$::internal::WireFormatLite::"
"total_size += ::_pbi::WireFormatLite::"
"$declared_type$SizePlusOne(this->_internal_$name$());\n");
} else {
format(
"total_size += $tag_size$ +\n"
" ::$proto_ns$::internal::WireFormatLite::$declared_type$Size(\n"
" ::_pbi::WireFormatLite::$declared_type$Size(\n"
" this->_internal_$name$());\n");
}
} else {
@ -227,10 +226,26 @@ void PrimitiveFieldGenerator::GenerateByteSize(io::Printer* printer) const {
}
}
void PrimitiveFieldGenerator::GenerateConstinitInitializer(
void PrimitiveFieldGenerator::GenerateConstexprAggregateInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_($default$)");
format("/*decltype($field$)*/$default$");
}
void PrimitiveFieldGenerator::GenerateAggregateInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
if (ShouldSplit(descriptor_, options_)) {
format("decltype(Impl_::Split::$name$_){$default$}");
return;
}
format("decltype($field$){$default$}");
}
void PrimitiveFieldGenerator::GenerateCopyAggregateInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("decltype($field$){}");
}
// ===================================================================
@ -249,7 +264,7 @@ void PrimitiveOneofFieldGenerator::GenerateInlineAccessorDefinitions(
format(
"inline $type$ $classname$::_internal_$name$() const {\n"
" if (_internal_has_$name$()) {\n"
" return $field_member$;\n"
" return $field$;\n"
" }\n"
" return $default$;\n"
"}\n"
@ -258,7 +273,7 @@ void PrimitiveOneofFieldGenerator::GenerateInlineAccessorDefinitions(
" clear_$oneof_name$();\n"
" set_has_$name$();\n"
" }\n"
" $field_member$ = value;\n"
" $field$ = value;\n"
"}\n"
"inline $type$ $classname$::$name$() const {\n"
"$annotate_get$"
@ -275,7 +290,7 @@ void PrimitiveOneofFieldGenerator::GenerateInlineAccessorDefinitions(
void PrimitiveOneofFieldGenerator::GenerateClearingCode(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("$field_member$ = $default$;\n");
format("$field$ = $default$;\n");
}
void PrimitiveOneofFieldGenerator::GenerateSwappingCode(
@ -286,7 +301,7 @@ void PrimitiveOneofFieldGenerator::GenerateSwappingCode(
void PrimitiveOneofFieldGenerator::GenerateConstructorCode(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("$ns$::_$classname$_default_instance_.$name$_ = $default$;\n");
format("$ns$::_$classname$_default_instance_.$field$ = $default$;\n");
}
// ===================================================================
@ -313,7 +328,7 @@ void RepeatedPrimitiveFieldGenerator::GeneratePrivateMembers(
format("::$proto_ns$::RepeatedField< $type$ > $name$_;\n");
if (descriptor_->is_packed() && FixedSize(descriptor_->type()) == -1 &&
HasGeneratedMethods(descriptor_->file(), options_)) {
format("mutable std::atomic<int> _$name$_cached_byte_size_;\n");
format("mutable std::atomic<int> $cached_byte_size_name$;\n");
}
}
@ -344,7 +359,7 @@ void RepeatedPrimitiveFieldGenerator::GenerateInlineAccessorDefinitions(
Formatter format(printer, variables_);
format(
"inline $type$ $classname$::_internal_$name$(int index) const {\n"
" return $name$_.Get(index);\n"
" return $field$.Get(index);\n"
"}\n"
"inline $type$ $classname$::$name$(int index) const {\n"
"$annotate_get$"
@ -353,11 +368,11 @@ void RepeatedPrimitiveFieldGenerator::GenerateInlineAccessorDefinitions(
"}\n"
"inline void $classname$::set_$name$(int index, $type$ value) {\n"
"$annotate_set$"
" $name$_.Set(index, value);\n"
" $field$.Set(index, value);\n"
" // @@protoc_insertion_point(field_set:$full_name$)\n"
"}\n"
"inline void $classname$::_internal_add_$name$($type$ value) {\n"
" $name$_.Add(value);\n"
" $field$.Add(value);\n"
"}\n"
"inline void $classname$::add_$name$($type$ value) {\n"
" _internal_add_$name$(value);\n"
@ -366,7 +381,7 @@ void RepeatedPrimitiveFieldGenerator::GenerateInlineAccessorDefinitions(
"}\n"
"inline const ::$proto_ns$::RepeatedField< $type$ >&\n"
"$classname$::_internal_$name$() const {\n"
" return $name$_;\n"
" return $field$;\n"
"}\n"
"inline const ::$proto_ns$::RepeatedField< $type$ >&\n"
"$classname$::$name$() const {\n"
@ -376,7 +391,7 @@ void RepeatedPrimitiveFieldGenerator::GenerateInlineAccessorDefinitions(
"}\n"
"inline ::$proto_ns$::RepeatedField< $type$ >*\n"
"$classname$::_internal_mutable_$name$() {\n"
" return &$name$_;\n"
" return &$field$;\n"
"}\n"
"inline ::$proto_ns$::RepeatedField< $type$ >*\n"
"$classname$::mutable_$name$() {\n"
@ -389,30 +404,25 @@ void RepeatedPrimitiveFieldGenerator::GenerateInlineAccessorDefinitions(
void RepeatedPrimitiveFieldGenerator::GenerateClearingCode(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_.Clear();\n");
format("$field$.Clear();\n");
}
void RepeatedPrimitiveFieldGenerator::GenerateMergingCode(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_.MergeFrom(from.$name$_);\n");
format("_this->$field$.MergeFrom(from.$field$);\n");
}
void RepeatedPrimitiveFieldGenerator::GenerateSwappingCode(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_.InternalSwap(&other->$name$_);\n");
format("$field$.InternalSwap(&other->$field$);\n");
}
void RepeatedPrimitiveFieldGenerator::GenerateConstructorCode(
io::Printer* printer) const {
// Not needed for repeated fields.
}
void RepeatedPrimitiveFieldGenerator::GenerateCopyConstructorCode(
void RepeatedPrimitiveFieldGenerator::GenerateDestructorCode(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_.CopyFrom(from.$name$_);\n");
format("$field$.~RepeatedField();\n");
}
void RepeatedPrimitiveFieldGenerator::GenerateSerializeWithCachedSizesToArray(
@ -423,7 +433,7 @@ void RepeatedPrimitiveFieldGenerator::GenerateSerializeWithCachedSizesToArray(
format(
"{\n"
" int byte_size = "
"_$name$_cached_byte_size_.load(std::memory_order_relaxed);\n"
"$cached_byte_size_field$.load(std::memory_order_relaxed);\n"
" if (byte_size > 0) {\n"
" target = stream->Write$declared_type$Packed(\n"
" $number$, _internal_$name$(), byte_size, target);\n"
@ -440,7 +450,7 @@ void RepeatedPrimitiveFieldGenerator::GenerateSerializeWithCachedSizesToArray(
format(
"for (int i = 0, n = this->_internal_$name$_size(); i < n; i++) {\n"
" target = stream->EnsureSpace(target);\n"
" target = ::$proto_ns$::internal::WireFormatLite::"
" target = ::_pbi::WireFormatLite::"
"Write$declared_type$ToArray($number$, this->_internal_$name$(i), "
"target);\n"
"}\n");
@ -455,8 +465,8 @@ void RepeatedPrimitiveFieldGenerator::GenerateByteSize(
int fixed_size = FixedSize(descriptor_->type());
if (fixed_size == -1) {
format(
"size_t data_size = ::$proto_ns$::internal::WireFormatLite::\n"
" $declared_type$Size(this->$name$_);\n");
"size_t data_size = ::_pbi::WireFormatLite::\n"
" $declared_type$Size(this->$field$);\n");
} else {
format(
"unsigned int count = static_cast<unsigned "
@ -468,13 +478,13 @@ void RepeatedPrimitiveFieldGenerator::GenerateByteSize(
format(
"if (data_size > 0) {\n"
" total_size += $tag_size$ +\n"
" ::$proto_ns$::internal::WireFormatLite::Int32Size(\n"
" static_cast<$int32$>(data_size));\n"
" "
"::_pbi::WireFormatLite::Int32Size(static_cast<$int32$>(data_size));\n"
"}\n");
if (FixedSize(descriptor_->type()) == -1) {
format(
"int cached_size = ::$proto_ns$::internal::ToCachedSize(data_size);\n"
"_$name$_cached_byte_size_.store(cached_size,\n"
"int cached_size = ::_pbi::ToCachedSize(data_size);\n"
"$cached_byte_size_field$.store(cached_size,\n"
" std::memory_order_relaxed);\n");
}
format("total_size += data_size;\n");
@ -482,20 +492,44 @@ void RepeatedPrimitiveFieldGenerator::GenerateByteSize(
format(
"total_size += $tag_size$ *\n"
" "
"::$proto_ns$::internal::FromIntSize(this->_internal_$name$_size());\n"
"::_pbi::FromIntSize(this->_internal_$name$_size());\n"
"total_size += data_size;\n");
}
format.Outdent();
format("}\n");
}
void RepeatedPrimitiveFieldGenerator::GenerateConstinitInitializer(
void RepeatedPrimitiveFieldGenerator::GenerateConstexprAggregateInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_()");
format("/*decltype($field$)*/{}");
if (descriptor_->is_packed() && FixedSize(descriptor_->type()) == -1 &&
HasGeneratedMethods(descriptor_->file(), options_)) {
format("\n, _$name$_cached_byte_size_(0)");
format("\n, /*decltype($cached_byte_size_field$)*/{0}");
}
}
void RepeatedPrimitiveFieldGenerator::GenerateAggregateInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("decltype($field$){arena}");
if (descriptor_->is_packed() && FixedSize(descriptor_->type()) == -1 &&
HasGeneratedMethods(descriptor_->file(), options_)) {
// std::atomic has no move constructor, which prevents explicit aggregate
// initialization pre-C++17.
format("\n, /*decltype($cached_byte_size_field$)*/{0}");
}
}
void RepeatedPrimitiveFieldGenerator::GenerateCopyAggregateInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("decltype($field$){from.$field$}");
if (descriptor_->is_packed() && FixedSize(descriptor_->type()) == -1 &&
HasGeneratedMethods(descriptor_->file(), options_)) {
// std::atomic has no move constructor.
format("\n, /*decltype($cached_byte_size_field$)*/{0}");
}
}

28
r5dev/thirdparty/protobuf/compiler/cpp/cpp_primitive_field.h → r5dev/thirdparty/protobuf/compiler/cpp/primitive_field.h vendored
View File

@ -37,7 +37,8 @@
#include <map>
#include <string>
#include <thirdparty/protobuf/compiler/cpp/cpp_field.h>
#include <thirdparty/protobuf/compiler/cpp/field.h>
namespace google {
namespace protobuf {
@ -48,7 +49,7 @@ class PrimitiveFieldGenerator : public FieldGenerator {
public:
PrimitiveFieldGenerator(const FieldDescriptor* descriptor,
const Options& options);
~PrimitiveFieldGenerator();
~PrimitiveFieldGenerator() override;
// implements FieldGenerator ---------------------------------------
void GeneratePrivateMembers(io::Printer* printer) const override;
@ -57,12 +58,15 @@ class PrimitiveFieldGenerator : public FieldGenerator {
void GenerateClearingCode(io::Printer* printer) const override;
void GenerateMergingCode(io::Printer* printer) const override;
void GenerateSwappingCode(io::Printer* printer) const override;
void GenerateConstructorCode(io::Printer* printer) const override;
void GenerateConstructorCode(io::Printer* printer) const override {}
void GenerateCopyConstructorCode(io::Printer* printer) const override;
void GenerateSerializeWithCachedSizesToArray(
io::Printer* printer) const override;
void GenerateByteSize(io::Printer* printer) const override;
void GenerateConstinitInitializer(io::Printer* printer) const override;
void GenerateConstexprAggregateInitializer(
io::Printer* printer) const override;
void GenerateAggregateInitializer(io::Printer* printer) const override;
void GenerateCopyAggregateInitializer(io::Printer* printer) const override;
private:
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(PrimitiveFieldGenerator);
@ -72,7 +76,7 @@ class PrimitiveOneofFieldGenerator : public PrimitiveFieldGenerator {
public:
PrimitiveOneofFieldGenerator(const FieldDescriptor* descriptor,
const Options& options);
~PrimitiveOneofFieldGenerator();
~PrimitiveOneofFieldGenerator() override;
// implements FieldGenerator ---------------------------------------
void GenerateInlineAccessorDefinitions(io::Printer* printer) const override;
@ -88,7 +92,7 @@ class RepeatedPrimitiveFieldGenerator : public FieldGenerator {
public:
RepeatedPrimitiveFieldGenerator(const FieldDescriptor* descriptor,
const Options& options);
~RepeatedPrimitiveFieldGenerator();
~RepeatedPrimitiveFieldGenerator() override;
// implements FieldGenerator ---------------------------------------
void GeneratePrivateMembers(io::Printer* printer) const override;
@ -97,12 +101,18 @@ class RepeatedPrimitiveFieldGenerator : public FieldGenerator {
void GenerateClearingCode(io::Printer* printer) const override;
void GenerateMergingCode(io::Printer* printer) const override;
void GenerateSwappingCode(io::Printer* printer) const override;
void GenerateConstructorCode(io::Printer* printer) const override;
void GenerateCopyConstructorCode(io::Printer* printer) const override;
void GenerateConstructorCode(io::Printer* printer) const override {}
void GenerateCopyConstructorCode(io::Printer* /*printer*/) const override {
GOOGLE_CHECK(!ShouldSplit(descriptor_, options_));
}
void GenerateDestructorCode(io::Printer* printer) const override;
void GenerateSerializeWithCachedSizesToArray(
io::Printer* printer) const override;
void GenerateByteSize(io::Printer* printer) const override;
void GenerateConstinitInitializer(io::Printer* printer) const override;
void GenerateConstexprAggregateInitializer(
io::Printer* printer) const override;
void GenerateAggregateInitializer(io::Printer* printer) const override;
void GenerateCopyAggregateInitializer(io::Printer* printer) const override;
private:
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(RepeatedPrimitiveFieldGenerator);

5
r5dev/thirdparty/protobuf/compiler/cpp/cpp_service.cc → r5dev/thirdparty/protobuf/compiler/cpp/service.cc vendored
View File

@ -32,10 +32,11 @@
// Based on original Protocol Buffers design by
// Sanjay Ghemawat, Jeff Dean, and others.
#include <thirdparty/protobuf/compiler/cpp/cpp_service.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_helpers.h>
#include <thirdparty/protobuf/compiler/cpp/service.h>
#include <thirdparty/protobuf/io/printer.h>
#include <thirdparty/protobuf/stubs/strutil.h>
#include <thirdparty/protobuf/compiler/cpp/helpers.h>
namespace google {
namespace protobuf {

3
r5dev/thirdparty/protobuf/compiler/cpp/cpp_service.h → r5dev/thirdparty/protobuf/compiler/cpp/service.h vendored
View File

@ -37,8 +37,9 @@
#include <map>
#include <string>
#include <thirdparty/protobuf/compiler/cpp/cpp_options.h>
#include <thirdparty/protobuf/descriptor.h>
#include <thirdparty/protobuf/compiler/cpp/options.h>
namespace google {
namespace protobuf {

328
r5dev/thirdparty/protobuf/compiler/cpp/cpp_string_field.cc → r5dev/thirdparty/protobuf/compiler/cpp/string_field.cc vendored
View File

@ -32,11 +32,12 @@
// Based on original Protocol Buffers design by
// Sanjay Ghemawat, Jeff Dean, and others.
#include <thirdparty/protobuf/compiler/cpp/cpp_string_field.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_helpers.h>
#include <thirdparty/protobuf/descriptor.pb.h>
#include <thirdparty/protobuf/compiler/cpp/string_field.h>
#include <thirdparty/protobuf/io/printer.h>
#include <thirdparty/protobuf/stubs/strutil.h>
#include <thirdparty/protobuf/compiler/cpp/helpers.h>
#include <thirdparty/protobuf/descriptor.pb.h>
namespace google {
@ -50,36 +51,30 @@ void SetStringVariables(const FieldDescriptor* descriptor,
std::map<std::string, std::string>* variables,
const Options& options) {
SetCommonFieldVariables(descriptor, variables, options);
const std::string kNS = "::" + (*variables)["proto_ns"] + "::internal::";
const std::string kArenaStringPtr = kNS + "ArenaStringPtr";
(*variables)["default"] = DefaultValue(options, descriptor);
(*variables)["default_length"] =
StrCat(descriptor->default_value_string().length());
std::string default_variable_string = MakeDefaultName(descriptor);
(*variables)["default_variable_name"] = default_variable_string;
(*variables)["default_variable_name"] = MakeDefaultName(descriptor);
(*variables)["default_variable_field"] = MakeDefaultFieldName(descriptor);
if (!descriptor->default_value_string().empty()) {
if (descriptor->default_value_string().empty()) {
(*variables)["default_string"] = kNS + "GetEmptyStringAlreadyInited()";
(*variables)["default_value"] = "&" + (*variables)["default_string"];
(*variables)["lazy_variable_args"] = "";
} else {
(*variables)["lazy_variable"] =
QualifiedClassName(descriptor->containing_type(), options) +
"::" + default_variable_string;
StrCat(QualifiedClassName(descriptor->containing_type(), options),
"::", MakeDefaultFieldName(descriptor));
(*variables)["default_string"] = (*variables)["lazy_variable"] + ".get()";
(*variables)["default_value"] = "nullptr";
(*variables)["lazy_variable_args"] = (*variables)["lazy_variable"] + ", ";
}
(*variables)["default_string"] =
descriptor->default_value_string().empty()
? "::" + (*variables)["proto_ns"] +
"::internal::GetEmptyStringAlreadyInited()"
: (*variables)["lazy_variable"] + ".get()";
(*variables)["init_value"] =
descriptor->default_value_string().empty()
? "&::" + (*variables)["proto_ns"] +
"::internal::GetEmptyStringAlreadyInited()"
: "nullptr";
(*variables)["default_value_tag"] =
"::" + (*variables)["proto_ns"] + "::internal::ArenaStringPtr::" +
(descriptor->default_value_string().empty() ? "Empty" : "NonEmpty") +
"Default{}";
(*variables)["default_variable_or_tag"] =
(*variables)[descriptor->default_value_string().empty()
? "default_value_tag"
: "lazy_variable"];
(*variables)["pointer_type"] =
descriptor->type() == FieldDescriptor::TYPE_BYTES ? "void" : "char";
(*variables)["setter"] =
@ -116,10 +111,11 @@ void StringFieldGenerator::GeneratePrivateMembers(io::Printer* printer) const {
if (!inlined_) {
format("::$proto_ns$::internal::ArenaStringPtr $name$_;\n");
} else {
// `_init_inline_xxx` is used for initializing default instances.
format(
"::$proto_ns$::internal::InlinedStringField $name$_;\n"
"static std::true_type _init_inline_$name$_;\n");
// Skips the automatic destruction; rather calls it explicitly if
// allocating arena is null. This is required to support message-owned
// arena (go/path-to-arenas) where a root proto is destroyed but
// InlinedStringField may have arena-allocated memory.
format("::$proto_ns$::internal::InlinedStringField $name$_;\n");
}
}
@ -130,6 +126,10 @@ void StringFieldGenerator::GenerateStaticMembers(io::Printer* printer) const {
"static const ::$proto_ns$::internal::LazyString"
" $default_variable_name$;\n");
}
if (inlined_) {
// `_init_inline_xxx` is used for initializing default instances.
format("static std::true_type _init_inline_$name$_;\n");
}
}
void StringFieldGenerator::GenerateAccessorDeclarations(
@ -204,8 +204,8 @@ void StringFieldGenerator::GenerateInlineAccessorDefinitions(
" // @@protoc_insertion_point(field_get:$full_name$)\n");
if (!descriptor_->default_value_string().empty()) {
format(
" if ($name$_.IsDefault(nullptr)) return "
"$default_variable_name$.get();\n");
" if ($field$.IsDefault()) return "
"$default_variable_field$.get();\n");
}
format(
" return _internal_$name$();\n"
@ -215,8 +215,9 @@ void StringFieldGenerator::GenerateInlineAccessorDefinitions(
"template <typename ArgT0, typename... ArgT>\n"
"inline PROTOBUF_ALWAYS_INLINE\n"
"void $classname$::set_$name$(ArgT0&& arg0, ArgT... args) {\n"
"$maybe_prepare_split_message$"
" $set_hasbit$\n"
" $name$_.$setter$($default_value_tag$, static_cast<ArgT0 &&>(arg0),"
" $field$.$setter$(static_cast<ArgT0 &&>(arg0),"
" args..., GetArenaForAllocation());\n"
"$annotate_set$"
" // @@protoc_insertion_point(field_set:$full_name$)\n"
@ -226,10 +227,11 @@ void StringFieldGenerator::GenerateInlineAccessorDefinitions(
"template <typename ArgT0, typename... ArgT>\n"
"inline PROTOBUF_ALWAYS_INLINE\n"
"void $classname$::set_$name$(ArgT0&& arg0, ArgT... args) {\n"
"$maybe_prepare_split_message$"
" $set_hasbit$\n"
" $name$_.$setter$(nullptr, static_cast<ArgT0 &&>(arg0),"
" $field$.$setter$(static_cast<ArgT0 &&>(arg0),"
" args..., GetArenaForAllocation(), _internal_$name$_donated(), "
"&$donating_states_word$, $mask_for_undonate$);\n"
"&$donating_states_word$, $mask_for_undonate$, this);\n"
"$annotate_set$"
" // @@protoc_insertion_point(field_set:$full_name$)\n"
"}\n"
@ -240,26 +242,27 @@ void StringFieldGenerator::GenerateInlineAccessorDefinitions(
}
format(
"inline std::string* $classname$::mutable_$name$() {\n"
"$maybe_prepare_split_message$"
" std::string* _s = _internal_mutable_$name$();\n"
"$annotate_mutable$"
" // @@protoc_insertion_point(field_mutable:$full_name$)\n"
" return _s;\n"
"}\n"
"inline const std::string& $classname$::_internal_$name$() const {\n"
" return $name$_.Get();\n"
" return $field$.Get();\n"
"}\n"
"inline void $classname$::_internal_set_$name$(const std::string& "
"value) {\n"
" $set_hasbit$\n");
if (!inlined_) {
format(
" $name$_.Set($default_value_tag$, value, GetArenaForAllocation());\n"
" $field$.Set(value, GetArenaForAllocation());\n"
"}\n");
} else {
format(
" $name$_.Set(nullptr, value, GetArenaForAllocation(),\n"
" $field$.Set(value, GetArenaForAllocation(),\n"
" _internal_$name$_donated(), &$donating_states_word$, "
"$mask_for_undonate$);\n"
"$mask_for_undonate$, this);\n"
"}\n");
}
format(
@ -267,19 +270,20 @@ void StringFieldGenerator::GenerateInlineAccessorDefinitions(
" $set_hasbit$\n");
if (!inlined_) {
format(
" return $name$_.Mutable($default_variable_or_tag$, "
" return $field$.Mutable($lazy_variable_args$"
"GetArenaForAllocation());\n"
"}\n");
} else {
format(
" return $name$_.Mutable($default_variable_or_tag$, "
" return $field$.Mutable($lazy_variable_args$"
"GetArenaForAllocation(), _internal_$name$_donated(), "
"&$donating_states_word$, $mask_for_undonate$);\n"
"&$donating_states_word$, $mask_for_undonate$, this);\n"
"}\n");
}
format(
"inline std::string* $classname$::$release_name$() {\n"
"$annotate_release$"
"$maybe_prepare_split_message$"
" // @@protoc_insertion_point(field_release:$full_name$)\n");
if (HasHasbit(descriptor_)) {
@ -289,54 +293,50 @@ void StringFieldGenerator::GenerateInlineAccessorDefinitions(
" }\n"
" $clear_hasbit$\n");
if (!inlined_) {
format(
" auto* p = $name$_.ReleaseNonDefault($init_value$, "
"GetArenaForAllocation());\n");
format(" auto* p = $field$.Release();\n");
if (descriptor_->default_value_string().empty()) {
format(
"#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING\n"
" if ($name$_.IsDefault($init_value$)) {\n"
" $name$_.Set($init_value$, \"\", GetArenaForAllocation());\n"
" if ($field$.IsDefault()) {\n"
" $field$.Set(\"\", GetArenaForAllocation());\n"
" }\n"
"#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING\n");
}
format(" return p;\n");
} else {
format(
" return $name$_.Release(nullptr, GetArenaForAllocation(), "
" return $field$.Release(GetArenaForAllocation(), "
"_internal_$name$_donated());\n");
}
} else {
format(
" return $name$_.Release($init_value$, GetArenaForAllocation());\n");
format(" return $field$.Release();\n");
}
format(
"}\n"
"inline void $classname$::set_allocated_$name$(std::string* $name$) {\n"
"$maybe_prepare_split_message$"
" if ($name$ != nullptr) {\n"
" $set_hasbit$\n"
" } else {\n"
" $clear_hasbit$\n"
" }\n");
if (!inlined_) {
format(
" $name$_.SetAllocated($init_value$, $name$,\n"
" GetArenaForAllocation());\n");
format(" $field$.SetAllocated($name$, GetArenaForAllocation());\n");
if (descriptor_->default_value_string().empty()) {
format(
"#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING\n"
" if ($name$_.IsDefault($init_value$)) {\n"
" $name$_.Set($init_value$, \"\", GetArenaForAllocation());\n"
" if ($field$.IsDefault()) {\n"
" $field$.Set(\"\", GetArenaForAllocation());\n"
" }\n"
"#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING\n");
}
} else {
// Currently, string fields with default value can't be inlined.
format(
" $name$_.SetAllocated(nullptr, $name$, GetArenaForAllocation(), "
" $field$.SetAllocated(nullptr, $name$, GetArenaForAllocation(), "
"_internal_$name$_donated(), &$donating_states_word$, "
"$mask_for_undonate$);\n");
"$mask_for_undonate$, this);\n");
}
format(
"$annotate_set$"
@ -350,7 +350,7 @@ void StringFieldGenerator::GenerateNonInlineAccessorDefinitions(
if (!descriptor_->default_value_string().empty()) {
format(
"const ::$proto_ns$::internal::LazyString "
"$classname$::$default_variable_name$"
"$classname$::$default_variable_field$"
"{{{$default$, $default_length$}}, {nullptr}};\n");
}
}
@ -358,11 +358,11 @@ void StringFieldGenerator::GenerateNonInlineAccessorDefinitions(
void StringFieldGenerator::GenerateClearingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
if (descriptor_->default_value_string().empty()) {
format("$name$_.ClearToEmpty();\n");
format("$field$.ClearToEmpty();\n");
} else {
GOOGLE_DCHECK(!inlined_);
format(
"$name$_.ClearToDefault($lazy_variable$, GetArenaForAllocation());\n");
"$field$.ClearToDefault($lazy_variable$, GetArenaForAllocation());\n");
}
}
@ -388,27 +388,27 @@ void StringFieldGenerator::GenerateMessageClearingCode(
//
// For non-inlined strings, we distinguish from non-default by comparing
// instances, rather than contents.
format("$DCHK$(!$name$_.IsDefault(nullptr));\n");
format("$DCHK$(!$field$.IsDefault());\n");
}
if (descriptor_->default_value_string().empty()) {
if (must_be_present) {
format("$name$_.ClearNonDefaultToEmpty();\n");
format("$field$.ClearNonDefaultToEmpty();\n");
} else {
format("$name$_.ClearToEmpty();\n");
format("$field$.ClearToEmpty();\n");
}
} else {
// Clear to a non-empty default is more involved, as we try to use the
// Arena if one is present and may need to reallocate the string.
format(
"$name$_.ClearToDefault($lazy_variable$, GetArenaForAllocation());\n ");
"$field$.ClearToDefault($lazy_variable$, GetArenaForAllocation());\n ");
}
}
void StringFieldGenerator::GenerateMergingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
// TODO(gpike): improve this
format("_internal_set_$name$(from._internal_$name$());\n");
format("_this->_internal_set_$name$(from._internal_$name$());\n");
}
void StringFieldGenerator::GenerateSwappingCode(io::Printer* printer) const {
@ -416,34 +416,46 @@ void StringFieldGenerator::GenerateSwappingCode(io::Printer* printer) const {
if (!inlined_) {
format(
"::$proto_ns$::internal::ArenaStringPtr::InternalSwap(\n"
" $init_value$,\n"
" &$name$_, lhs_arena,\n"
" &other->$name$_, rhs_arena\n"
" &$field$, lhs_arena,\n"
" &other->$field$, rhs_arena\n"
");\n");
} else {
// At this point, it's guaranteed that the two fields being swapped are on
// the same arena.
format(
"$name$_.Swap(&other->$name$_, nullptr, GetArenaForAllocation(), "
"_internal_$name$_donated(), other->_internal_$name$_donated(), "
"&$donating_states_word$, &(other->$donating_states_word$), "
"$mask_for_undonate$);\n");
"::$proto_ns$::internal::InlinedStringField::InternalSwap(\n"
" &$field$, lhs_arena, "
"($inlined_string_donated_array$[0] & 0x1u) == 0, this,\n"
" &other->$field$, rhs_arena, "
"(other->$inlined_string_donated_array$[0] & 0x1u) == 0, other);\n");
}
}
void StringFieldGenerator::GenerateConstructorCode(io::Printer* printer) const {
Formatter format(printer, variables_);
if (inlined_ && descriptor_->default_value_string().empty()) {
// Automatic initialization will construct the string.
return;
}
GOOGLE_DCHECK(!inlined_);
format("$name$_.UnsafeSetDefault($init_value$);\n");
format("$field$.InitDefault();\n");
if (IsString(descriptor_, options_) &&
descriptor_->default_value_string().empty()) {
format(
"#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING\n"
" $name$_.Set($init_value$, \"\", GetArenaForAllocation());\n"
" $field$.Set(\"\", GetArenaForAllocation());\n"
"#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING\n");
}
}
void StringFieldGenerator::GenerateCreateSplitMessageCode(
io::Printer* printer) const {
GOOGLE_CHECK(ShouldSplit(descriptor_, options_));
GOOGLE_CHECK(!inlined_);
Formatter format(printer, variables_);
format("ptr->$name$_.InitDefault();\n");
if (IsString(descriptor_, options_) &&
descriptor_->default_value_string().empty()) {
format(
"#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING\n"
" ptr->$name$_.Set(\"\", GetArenaForAllocation());\n"
"#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING\n");
}
}
@ -452,6 +464,9 @@ void StringFieldGenerator::GenerateCopyConstructorCode(
io::Printer* printer) const {
Formatter format(printer, variables_);
GenerateConstructorCode(printer);
if (inlined_) {
format("new (&_this->$field$) ::_pbi::InlinedStringField();\n");
}
if (HasHasbit(descriptor_)) {
format("if (from._internal_has_$name$()) {\n");
@ -463,13 +478,13 @@ void StringFieldGenerator::GenerateCopyConstructorCode(
if (!inlined_) {
format(
"$name$_.Set($default_value_tag$, from._internal_$name$(), \n"
" GetArenaForAllocation());\n");
"_this->$field$.Set(from._internal_$name$(), \n"
" _this->GetArenaForAllocation());\n");
} else {
format(
"$name$_.Set(nullptr, from._internal_$name$(),\n"
" GetArenaForAllocation(), _internal_$name$_donated(), "
"&$donating_states_word$, $mask_for_undonate$);\n");
"_this->$field$.Set(from._internal_$name$(),\n"
" _this->GetArenaForAllocation(), _this->_internal_$name$_donated(), "
"&_this->$donating_states_word$, $mask_for_undonate$, _this);\n");
}
format.Outdent();
@ -478,12 +493,35 @@ void StringFieldGenerator::GenerateCopyConstructorCode(
void StringFieldGenerator::GenerateDestructorCode(io::Printer* printer) const {
Formatter format(printer, variables_);
if (inlined_) {
// The destructor is automatically invoked.
if (!inlined_) {
if (ShouldSplit(descriptor_, options_)) {
format("$cached_split_ptr$->$name$_.Destroy();\n");
return;
}
format("$field$.Destroy();\n");
return;
}
// Explicitly calls ~InlinedStringField as its automatic call is disabled.
// Destructor has been implicitly skipped as a union, and even the
// message-owned arena is enabled, arena could still be missing for
// Arena::CreateMessage(nullptr).
GOOGLE_DCHECK(!ShouldSplit(descriptor_, options_));
format("$field$.~InlinedStringField();\n");
}
format("$name$_.DestroyNoArena($init_value$);\n");
ArenaDtorNeeds StringFieldGenerator::NeedsArenaDestructor() const {
return inlined_ ? ArenaDtorNeeds::kOnDemand : ArenaDtorNeeds::kNone;
}
void StringFieldGenerator::GenerateArenaDestructorCode(
io::Printer* printer) const {
if (!inlined_) return;
Formatter format(printer, variables_);
// _this is the object being destructed (we are inside a static method here).
format(
"if (!_this->_internal_$name$_donated()) {\n"
" _this->$field$.~InlinedStringField();\n"
"}\n");
}
void StringFieldGenerator::GenerateSerializeWithCachedSizesToArray(
@ -509,20 +547,43 @@ void StringFieldGenerator::GenerateByteSize(io::Printer* printer) const {
" this->_internal_$name$());\n");
}
void StringFieldGenerator::GenerateConstinitInitializer(
void StringFieldGenerator::GenerateConstexprAggregateInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
if (inlined_) {
format("$name$_(nullptr, false)");
format("/*decltype($field$)*/{nullptr, false}");
return;
}
if (descriptor_->default_value_string().empty()) {
format("$name$_(&::$proto_ns$::internal::fixed_address_empty_string)");
format(
"/*decltype($field$)*/{&::_pbi::fixed_address_empty_string, "
"::_pbi::ConstantInitialized{}}");
} else {
format("$name$_(nullptr)");
format("/*decltype($field$)*/{nullptr, ::_pbi::ConstantInitialized{}}");
}
}
void StringFieldGenerator::GenerateAggregateInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
if (ShouldSplit(descriptor_, options_)) {
GOOGLE_CHECK(!inlined_);
format("decltype(Impl_::Split::$name$_){}");
return;
}
if (!inlined_) {
format("decltype($field$){}");
} else {
format("decltype($field$)(arena)");
}
}
void StringFieldGenerator::GenerateCopyAggregateInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("decltype($field$){}");
}
// ===================================================================
StringOneofFieldGenerator::StringOneofFieldGenerator(
@ -550,9 +611,9 @@ void StringOneofFieldGenerator::GenerateInlineAccessorDefinitions(
" if (!_internal_has_$name$()) {\n"
" clear_$oneof_name$();\n"
" set_has_$name$();\n"
" $field_member$.UnsafeSetDefault($init_value$);\n"
" $field$.InitDefault();\n"
" }\n"
" $field_member$.$setter$($default_value_tag$,"
" $field$.$setter$("
" static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());\n"
"$annotate_set$"
" // @@protoc_insertion_point(field_set:$full_name$)\n"
@ -565,7 +626,7 @@ void StringOneofFieldGenerator::GenerateInlineAccessorDefinitions(
"}\n"
"inline const std::string& $classname$::_internal_$name$() const {\n"
" if (_internal_has_$name$()) {\n"
" return $field_member$.Get();\n"
" return $field$.Get();\n"
" }\n"
" return $default_string$;\n"
"}\n"
@ -574,28 +635,26 @@ void StringOneofFieldGenerator::GenerateInlineAccessorDefinitions(
" if (!_internal_has_$name$()) {\n"
" clear_$oneof_name$();\n"
" set_has_$name$();\n"
" $field_member$.UnsafeSetDefault($init_value$);\n"
" $field$.InitDefault();\n"
" }\n"
" $field_member$.Set($default_value_tag$, value, "
"GetArenaForAllocation());\n"
" $field$.Set(value, GetArenaForAllocation());\n"
"}\n");
format(
"inline std::string* $classname$::_internal_mutable_$name$() {\n"
" if (!_internal_has_$name$()) {\n"
" clear_$oneof_name$();\n"
" set_has_$name$();\n"
" $field_member$.UnsafeSetDefault($init_value$);\n"
" $field$.InitDefault();\n"
" }\n"
" return $field_member$.Mutable(\n"
" $default_variable_or_tag$, GetArenaForAllocation());\n"
" return $field$.Mutable($lazy_variable_args$"
" GetArenaForAllocation());\n"
"}\n"
"inline std::string* $classname$::$release_name$() {\n"
"$annotate_release$"
" // @@protoc_insertion_point(field_release:$full_name$)\n"
" if (_internal_has_$name$()) {\n"
" clear_has_$oneof_name$();\n"
" return $field_member$.ReleaseNonDefault($init_value$, "
"GetArenaForAllocation());\n"
" return $field$.Release();\n"
" } else {\n"
" return nullptr;\n"
" }\n"
@ -606,11 +665,7 @@ void StringOneofFieldGenerator::GenerateInlineAccessorDefinitions(
" }\n"
" if ($name$ != nullptr) {\n"
" set_has_$name$();\n"
" $field_member$.UnsafeSetDefault($name$);\n"
" ::$proto_ns$::Arena* arena = GetArenaForAllocation();\n"
" if (arena != nullptr) {\n"
" arena->Own($name$);\n"
" }\n"
" $field$.InitAllocated($name$, GetArenaForAllocation());\n"
" }\n"
"$annotate_set$"
" // @@protoc_insertion_point(field_set_allocated:$full_name$)\n"
@ -620,9 +675,7 @@ void StringOneofFieldGenerator::GenerateInlineAccessorDefinitions(
void StringOneofFieldGenerator::GenerateClearingCode(
io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"$field_member$.Destroy($default_value_tag$, "
"GetArenaForAllocation());\n");
format("$field$.Destroy();\n");
}
void StringOneofFieldGenerator::GenerateMessageClearingCode(
@ -737,14 +790,14 @@ void RepeatedStringFieldGenerator::GenerateInlineAccessorDefinitions(
format(
"inline const std::string& $classname$::_internal_$name$(int index) "
"const {\n"
" return $name$_.InternalCheckedGet(\n"
" return $field$.InternalCheckedGet(\n"
" index, ::$proto_ns$::internal::GetEmptyStringAlreadyInited());\n"
"}\n");
} else {
format(
"inline const std::string& $classname$::_internal_$name$(int index) "
"const {\n"
" return $name$_.Get(index);\n"
" return $field$.Get(index);\n"
"}\n");
}
format(
@ -756,23 +809,23 @@ void RepeatedStringFieldGenerator::GenerateInlineAccessorDefinitions(
"inline std::string* $classname$::mutable_$name$(int index) {\n"
"$annotate_mutable$"
" // @@protoc_insertion_point(field_mutable:$full_name$)\n"
" return $name$_.Mutable(index);\n"
" return $field$.Mutable(index);\n"
"}\n"
"inline void $classname$::set_$name$(int index, const std::string& "
"value) "
"{\n"
" $name$_.Mutable(index)->assign(value);\n"
" $field$.Mutable(index)->assign(value);\n"
"$annotate_set$"
" // @@protoc_insertion_point(field_set:$full_name$)\n"
"}\n"
"inline void $classname$::set_$name$(int index, std::string&& value) {\n"
" $name$_.Mutable(index)->assign(std::move(value));\n"
" $field$.Mutable(index)->assign(std::move(value));\n"
"$annotate_set$"
" // @@protoc_insertion_point(field_set:$full_name$)\n"
"}\n"
"inline void $classname$::set_$name$(int index, const char* value) {\n"
" $null_check$"
" $name$_.Mutable(index)->assign(value);\n"
" $field$.Mutable(index)->assign(value);\n"
"$annotate_set$"
" // @@protoc_insertion_point(field_set_char:$full_name$)\n"
"}\n");
@ -780,7 +833,7 @@ void RepeatedStringFieldGenerator::GenerateInlineAccessorDefinitions(
format(
"inline void "
"$classname$::set_$name$(int index, StringPiece value) {\n"
" $name$_.Mutable(index)->assign(value.data(), value.size());\n"
" $field$.Mutable(index)->assign(value.data(), value.size());\n"
"$annotate_set$"
" // @@protoc_insertion_point(field_set_string_piece:$full_name$)\n"
"}\n");
@ -789,34 +842,34 @@ void RepeatedStringFieldGenerator::GenerateInlineAccessorDefinitions(
"inline void "
"$classname$::set_$name$"
"(int index, const $pointer_type$* value, size_t size) {\n"
" $name$_.Mutable(index)->assign(\n"
" $field$.Mutable(index)->assign(\n"
" reinterpret_cast<const char*>(value), size);\n"
"$annotate_set$"
" // @@protoc_insertion_point(field_set_pointer:$full_name$)\n"
"}\n"
"inline std::string* $classname$::_internal_add_$name$() {\n"
" return $name$_.Add();\n"
" return $field$.Add();\n"
"}\n"
"inline void $classname$::add_$name$(const std::string& value) {\n"
" $name$_.Add()->assign(value);\n"
" $field$.Add()->assign(value);\n"
"$annotate_add$"
" // @@protoc_insertion_point(field_add:$full_name$)\n"
"}\n"
"inline void $classname$::add_$name$(std::string&& value) {\n"
" $name$_.Add(std::move(value));\n"
" $field$.Add(std::move(value));\n"
"$annotate_add$"
" // @@protoc_insertion_point(field_add:$full_name$)\n"
"}\n"
"inline void $classname$::add_$name$(const char* value) {\n"
" $null_check$"
" $name$_.Add()->assign(value);\n"
" $field$.Add()->assign(value);\n"
"$annotate_add$"
" // @@protoc_insertion_point(field_add_char:$full_name$)\n"
"}\n");
if (!options_.opensource_runtime) {
format(
"inline void $classname$::add_$name$(StringPiece value) {\n"
" $name$_.Add()->assign(value.data(), value.size());\n"
" $field$.Add()->assign(value.data(), value.size());\n"
"$annotate_add$"
" // @@protoc_insertion_point(field_add_string_piece:$full_name$)\n"
"}\n");
@ -824,7 +877,7 @@ void RepeatedStringFieldGenerator::GenerateInlineAccessorDefinitions(
format(
"inline void "
"$classname$::add_$name$(const $pointer_type$* value, size_t size) {\n"
" $name$_.Add()->assign(reinterpret_cast<const char*>(value), size);\n"
" $field$.Add()->assign(reinterpret_cast<const char*>(value), size);\n"
"$annotate_add$"
" // @@protoc_insertion_point(field_add_pointer:$full_name$)\n"
"}\n"
@ -832,43 +885,38 @@ void RepeatedStringFieldGenerator::GenerateInlineAccessorDefinitions(
"$classname$::$name$() const {\n"
"$annotate_list$"
" // @@protoc_insertion_point(field_list:$full_name$)\n"
" return $name$_;\n"
" return $field$;\n"
"}\n"
"inline ::$proto_ns$::RepeatedPtrField<std::string>*\n"
"$classname$::mutable_$name$() {\n"
"$annotate_mutable_list$"
" // @@protoc_insertion_point(field_mutable_list:$full_name$)\n"
" return &$name$_;\n"
" return &$field$;\n"
"}\n");
}
void RepeatedStringFieldGenerator::GenerateClearingCode(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_.Clear();\n");
format("$field$.Clear();\n");
}
void RepeatedStringFieldGenerator::GenerateMergingCode(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_.MergeFrom(from.$name$_);\n");
format("_this->$field$.MergeFrom(from.$field$);\n");
}
void RepeatedStringFieldGenerator::GenerateSwappingCode(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_.InternalSwap(&other->$name$_);\n");
format("$field$.InternalSwap(&other->$field$);\n");
}
void RepeatedStringFieldGenerator::GenerateConstructorCode(
io::Printer* printer) const {
// Not needed for repeated fields.
}
void RepeatedStringFieldGenerator::GenerateCopyConstructorCode(
void RepeatedStringFieldGenerator::GenerateDestructorCode(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_.CopyFrom(from.$name$_);");
format("$field$.~RepeatedPtrField();\n");
}
void RepeatedStringFieldGenerator::GenerateSerializeWithCachedSizesToArray(
@ -895,20 +943,14 @@ void RepeatedStringFieldGenerator::GenerateByteSize(
Formatter format(printer, variables_);
format(
"total_size += $tag_size$ *\n"
" ::$proto_ns$::internal::FromIntSize($name$_.size());\n"
"for (int i = 0, n = $name$_.size(); i < n; i++) {\n"
" ::$proto_ns$::internal::FromIntSize($field$.size());\n"
"for (int i = 0, n = $field$.size(); i < n; i++) {\n"
" total_size += "
"::$proto_ns$::internal::WireFormatLite::$declared_type$Size(\n"
" $name$_.Get(i));\n"
" $field$.Get(i));\n"
"}\n");
}
void RepeatedStringFieldGenerator::GenerateConstinitInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("$name$_()");
}
} // namespace cpp
} // namespace compiler
} // namespace protobuf

25
r5dev/thirdparty/protobuf/compiler/cpp/cpp_string_field.h → r5dev/thirdparty/protobuf/compiler/cpp/string_field.h vendored
View File

@ -37,7 +37,8 @@
#include <map>
#include <string>
#include <thirdparty/protobuf/compiler/cpp/cpp_field.h>
#include <thirdparty/protobuf/compiler/cpp/field.h>
namespace google {
namespace protobuf {
@ -48,7 +49,7 @@ class StringFieldGenerator : public FieldGenerator {
public:
StringFieldGenerator(const FieldDescriptor* descriptor,
const Options& options);
~StringFieldGenerator();
~StringFieldGenerator() override;
// implements FieldGenerator ---------------------------------------
void GeneratePrivateMembers(io::Printer* printer) const override;
@ -62,13 +63,19 @@ class StringFieldGenerator : public FieldGenerator {
void GenerateMergingCode(io::Printer* printer) const override;
void GenerateSwappingCode(io::Printer* printer) const override;
void GenerateConstructorCode(io::Printer* printer) const override;
void GenerateCreateSplitMessageCode(io::Printer* printer) const override;
void GenerateCopyConstructorCode(io::Printer* printer) const override;
void GenerateDestructorCode(io::Printer* printer) const override;
void GenerateArenaDestructorCode(io::Printer* printer) const override;
void GenerateSerializeWithCachedSizesToArray(
io::Printer* printer) const override;
void GenerateByteSize(io::Printer* printer) const override;
void GenerateConstinitInitializer(io::Printer* printer) const override;
void GenerateConstexprAggregateInitializer(
io::Printer* printer) const override;
void GenerateAggregateInitializer(io::Printer* printer) const override;
void GenerateCopyAggregateInitializer(io::Printer* printer) const override;
bool IsInlined() const override { return inlined_; }
ArenaDtorNeeds NeedsArenaDestructor() const override;
private:
bool inlined_;
@ -79,7 +86,7 @@ class StringOneofFieldGenerator : public StringFieldGenerator {
public:
StringOneofFieldGenerator(const FieldDescriptor* descriptor,
const Options& options);
~StringOneofFieldGenerator();
~StringOneofFieldGenerator() override;
// implements FieldGenerator ---------------------------------------
void GenerateInlineAccessorDefinitions(io::Printer* printer) const override;
@ -99,7 +106,7 @@ class RepeatedStringFieldGenerator : public FieldGenerator {
public:
RepeatedStringFieldGenerator(const FieldDescriptor* descriptor,
const Options& options);
~RepeatedStringFieldGenerator();
~RepeatedStringFieldGenerator() override;
// implements FieldGenerator ---------------------------------------
void GeneratePrivateMembers(io::Printer* printer) const override;
@ -108,12 +115,14 @@ class RepeatedStringFieldGenerator : public FieldGenerator {
void GenerateClearingCode(io::Printer* printer) const override;
void GenerateMergingCode(io::Printer* printer) const override;
void GenerateSwappingCode(io::Printer* printer) const override;
void GenerateConstructorCode(io::Printer* printer) const override;
void GenerateCopyConstructorCode(io::Printer* printer) const override;
void GenerateConstructorCode(io::Printer* printer) const override {}
void GenerateCopyConstructorCode(io::Printer* /*printer*/) const override {
GOOGLE_CHECK(!ShouldSplit(descriptor_, options_));
}
void GenerateDestructorCode(io::Printer* printer) const override;
void GenerateSerializeWithCachedSizesToArray(
io::Printer* printer) const override;
void GenerateByteSize(io::Printer* printer) const override;
void GenerateConstinitInitializer(io::Printer* printer) const override;
private:
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(RepeatedStringFieldGenerator);

0
r5dev/thirdparty/protobuf/compiler/cpp/cpp_test_bad_identifiers.proto → r5dev/thirdparty/protobuf/compiler/cpp/test_bad_identifiers.proto vendored
View File

0
r5dev/thirdparty/protobuf/compiler/cpp/cpp_test_large_enum_value.proto → r5dev/thirdparty/protobuf/compiler/cpp/test_large_enum_value.proto vendored
View File

5
r5dev/thirdparty/protobuf/compiler/cpp/cpp_unittest.cc → r5dev/thirdparty/protobuf/compiler/cpp/unittest.cc vendored
View File

@ -44,12 +44,11 @@
// correctly and produces the interfaces we expect, which is why this test
// is written this way.
#include <thirdparty/protobuf/compiler/cpp/cpp_unittest.h>
#include <thirdparty/protobuf/compiler/cpp/unittest.h>
#include <thirdparty/protobuf/unittest.pb.h>
#include <thirdparty/protobuf/unittest_embed_optimize_for.pb.h>
#include <thirdparty/protobuf/unittest_optimize_for.pb.h>
#include <thirdparty/protobuf/test_util.h>
#define MESSAGE_TEST_NAME MessageTest
@ -65,7 +64,7 @@
#define UNITTEST_IMPORT ::protobuf_unittest_import
// Must include after the above macros.
#include <thirdparty/protobuf/compiler/cpp/cpp_unittest.inc>
#include <thirdparty/protobuf/compiler/cpp/unittest.inc>
namespace google {
namespace protobuf {

0
r5dev/thirdparty/protobuf/compiler/cpp/cpp_unittest.h → r5dev/thirdparty/protobuf/compiler/cpp/unittest.h vendored
View File

316
r5dev/thirdparty/protobuf/compiler/cpp/cpp_unittest.inc → r5dev/thirdparty/protobuf/compiler/cpp/unittest.inc vendored
View File

@ -49,25 +49,25 @@
#include <memory>
#include <vector>
#include <thirdparty/protobuf/compiler/cpp/cpp_unittest.h>
#include <thirdparty/protobuf/compiler/cpp/unittest.h>
#include <thirdparty/protobuf/stubs/strutil.h>
#if !defined(GOOGLE_PROTOBUF_CMAKE_BUILD) && !defined(_MSC_VER)
// We exclude this large proto from cmake build because it's too large for
#ifndef _MSC_VER
// We exclude this large proto because it's too large for
// visual studio to compile (report internal errors).
#include <thirdparty/protobuf/unittest_enormous_descriptor.pb.h>
#endif
#include <thirdparty/protobuf/compiler/cpp/cpp_helpers.h>
#include <thirdparty/protobuf/compiler/cpp/cpp_test_bad_identifiers.pb.h>
#include <thirdparty/protobuf/compiler/scc.h>
#include <thirdparty/protobuf/compiler/importer.h>
#include <thirdparty/protobuf/test_util2.h>
#include <thirdparty/protobuf/compiler/cpp/helpers.h>
#include <thirdparty/protobuf/compiler/cpp/test_bad_identifiers.pb.h>
#include <thirdparty/protobuf/unittest_no_generic_services.pb.h>
#include <thirdparty/protobuf/io/coded_stream.h>
#include <thirdparty/protobuf/io/zero_copy_stream_impl.h>
#include <thirdparty/protobuf/descriptor.pb.h>
#include <thirdparty/protobuf/arena.h>
#include <thirdparty/protobuf/descriptor.h>
#include <thirdparty/protobuf/dynamic_message.h>
#include <thirdparty/protobuf/compiler/scc.h>
#include <thirdparty/protobuf/compiler/importer.h>
#include <thirdparty/protobuf/io/coded_stream.h>
#include <thirdparty/protobuf/io/zero_copy_stream_impl.h>
#include <thirdparty/protobuf/test_util2.h>
#include <thirdparty/protobuf/stubs/callback.h>
#include <thirdparty/protobuf/stubs/common.h>
@ -95,7 +95,7 @@ void DoNothing() {}
class MockErrorCollector : public MultiFileErrorCollector {
public:
MockErrorCollector() {}
~MockErrorCollector() {}
~MockErrorCollector() override {}
std::string text_;
@ -126,7 +126,7 @@ TEST(GENERATED_DESCRIPTOR_TEST_NAME, IdenticalDescriptors) {
const FileDescriptor* parsed_descriptor =
importer.Import(TestUtil::MaybeTranslatePath(UNITTEST_PROTO_PATH));
EXPECT_EQ("", error_collector.text_);
ASSERT_TRUE(parsed_descriptor != NULL);
ASSERT_TRUE(parsed_descriptor != nullptr);
// Test that descriptors are generated correctly by converting them to
// FileDescriptorProtos and comparing.
@ -138,7 +138,7 @@ TEST(GENERATED_DESCRIPTOR_TEST_NAME, IdenticalDescriptors) {
generated_descriptor_proto.DebugString());
}
#if !defined(GOOGLE_PROTOBUF_CMAKE_BUILD) && !defined(_MSC_VER)
#ifndef _MSC_VER
// Test that generated code has proper descriptors:
// Touch a descriptor generated from an enormous message to validate special
// handling for descriptors exceeding the C++ standard's recommended minimum
@ -147,7 +147,7 @@ TEST(GENERATED_DESCRIPTOR_TEST_NAME, EnormousDescriptor) {
const Descriptor* generated_descriptor =
::protobuf_unittest::TestEnormousDescriptor::descriptor();
EXPECT_TRUE(generated_descriptor != NULL);
EXPECT_TRUE(generated_descriptor != nullptr);
}
#endif
@ -249,11 +249,11 @@ TEST(GENERATED_MESSAGE_TEST_NAME, StringDefaults) {
}
TEST(GENERATED_MESSAGE_TEST_NAME, ReleaseString) {
// Check that release_foo() starts out NULL, and gives us a value
// Check that release_foo() starts out nullptr, and gives us a value
// that we can delete after it's been set.
UNITTEST::TestAllTypes message;
EXPECT_EQ(NULL, message.release_default_string());
EXPECT_EQ(nullptr, message.release_default_string());
EXPECT_FALSE(message.has_default_string());
EXPECT_EQ("hello", message.default_string());
@ -261,30 +261,30 @@ TEST(GENERATED_MESSAGE_TEST_NAME, ReleaseString) {
EXPECT_TRUE(message.has_default_string());
std::unique_ptr<std::string> str(message.release_default_string());
EXPECT_FALSE(message.has_default_string());
ASSERT_TRUE(str != NULL);
ASSERT_TRUE(str != nullptr);
EXPECT_EQ("blah", *str);
EXPECT_EQ(NULL, message.release_default_string());
EXPECT_EQ(nullptr, message.release_default_string());
EXPECT_FALSE(message.has_default_string());
EXPECT_EQ("hello", message.default_string());
}
TEST(GENERATED_MESSAGE_TEST_NAME, ReleaseMessage) {
// Check that release_foo() starts out NULL, and gives us a value
// Check that release_foo() starts out nullptr, and gives us a value
// that we can delete after it's been set.
UNITTEST::TestAllTypes message;
EXPECT_EQ(NULL, message.release_optional_nested_message());
EXPECT_EQ(nullptr, message.release_optional_nested_message());
EXPECT_FALSE(message.has_optional_nested_message());
message.mutable_optional_nested_message()->set_bb(1);
std::unique_ptr<UNITTEST::TestAllTypes::NestedMessage> nest(
message.release_optional_nested_message());
EXPECT_FALSE(message.has_optional_nested_message());
ASSERT_TRUE(nest != NULL);
ASSERT_TRUE(nest != nullptr);
EXPECT_EQ(1, nest->bb());
EXPECT_EQ(NULL, message.release_optional_nested_message());
EXPECT_EQ(nullptr, message.release_optional_nested_message());
EXPECT_FALSE(message.has_optional_nested_message());
}
@ -297,7 +297,7 @@ TEST(GENERATED_MESSAGE_TEST_NAME, SetAllocatedString) {
message.set_optional_string(kHello);
EXPECT_TRUE(message.has_optional_string());
message.set_allocated_optional_string(NULL);
message.set_allocated_optional_string(nullptr);
EXPECT_FALSE(message.has_optional_string());
EXPECT_EQ("", message.optional_string());
@ -315,7 +315,7 @@ TEST(GENERATED_MESSAGE_TEST_NAME, SetAllocatedMessage) {
message.mutable_optional_nested_message()->set_bb(1);
EXPECT_TRUE(message.has_optional_nested_message());
message.set_allocated_optional_nested_message(NULL);
message.set_allocated_optional_nested_message(nullptr);
EXPECT_FALSE(message.has_optional_nested_message());
EXPECT_EQ(&UNITTEST::TestAllTypes::NestedMessage::default_instance(),
&message.optional_nested_message());
@ -323,7 +323,7 @@ TEST(GENERATED_MESSAGE_TEST_NAME, SetAllocatedMessage) {
message.mutable_optional_nested_message()->set_bb(1);
UNITTEST::TestAllTypes::NestedMessage* nest =
message.release_optional_nested_message();
ASSERT_TRUE(nest != NULL);
ASSERT_TRUE(nest != nullptr);
EXPECT_FALSE(message.has_optional_nested_message());
message.set_allocated_optional_nested_message(nest);
@ -339,19 +339,6 @@ TEST(GENERATED_MESSAGE_TEST_NAME, Clear) {
TestUtil::SetAllFields(&message);
message.Clear();
TestUtil::ExpectClear(message);
// Unlike with the defaults test, we do NOT expect that requesting embedded
// messages will return a pointer to the default instance. Instead, they
// should return the objects that were created when mutable_blah() was
// called.
EXPECT_NE(&UNITTEST::TestAllTypes::OptionalGroup::default_instance(),
&message.optionalgroup());
EXPECT_NE(&UNITTEST::TestAllTypes::NestedMessage::default_instance(),
&message.optional_nested_message());
EXPECT_NE(&UNITTEST::ForeignMessage::default_instance(),
&message.optional_foreign_message());
EXPECT_NE(&UNITTEST_IMPORT::ImportMessage::default_instance(),
&message.optional_import_message());
}
TEST(GENERATED_MESSAGE_TEST_NAME, EmbeddedNullsInBytesCharStar) {
@ -406,6 +393,7 @@ TEST(GENERATED_MESSAGE_TEST_NAME, StringCharStarLength) {
}
#if !defined(PROTOBUF_TEST_NO_DESCRIPTORS) || defined(NDEBUG)
TEST(GENERATED_MESSAGE_TEST_NAME, CopyFrom) {
UNITTEST::TestAllTypes message1, message2;
@ -418,6 +406,20 @@ TEST(GENERATED_MESSAGE_TEST_NAME, CopyFrom) {
TestUtil::ExpectAllFieldsSet(message2);
}
TEST(GENERATED_MESSAGE_TEST_NAME, CopyAssignmentOperator) {
UNITTEST::TestAllTypes message1;
TestUtil::SetAllFields(&message1);
UNITTEST::TestAllTypes message2;
message2 = message1;
TestUtil::ExpectAllFieldsSet(message2);
// Make sure that self-assignment does something sane.
message2.operator=(message2);
TestUtil::ExpectAllFieldsSet(message2);
}
#endif // !PROTOBUF_TEST_NO_DESCRIPTORS || NDEBUG
TEST(GENERATED_MESSAGE_TEST_NAME, SwapWithEmpty) {
UNITTEST::TestAllTypes message1, message2;
@ -503,6 +505,9 @@ TEST(GENERATED_MESSAGE_TEST_NAME, ADLSwap) {
// Note the address of one of the repeated fields, to verify it was swapped
// rather than copied.
const int32_t* addr = &message1.repeated_int32().Get(0);
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
const int32_t value = *addr;
#endif
using std::swap;
swap(message1, message2);
@ -512,7 +517,7 @@ TEST(GENERATED_MESSAGE_TEST_NAME, ADLSwap) {
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
EXPECT_NE(addr, &message2.repeated_int32().Get(0));
EXPECT_EQ(*addr, message2.repeated_int32().Get(0));
EXPECT_EQ(value, message2.repeated_int32().Get(0));
#else
EXPECT_EQ(addr, &message2.repeated_int32().Get(0));
#endif
@ -531,6 +536,7 @@ TEST(GENERATED_MESSAGE_TEST_NAME, CopyConstructor) {
// None set.
{
UNITTEST::TestAllTypes message1;
// NOLINTNEXTLINE(performance-unnecessary-copy-initialization)
UNITTEST::TestAllTypes message2(message1);
EXPECT_FALSE(message1.has_optional_string());
@ -588,20 +594,7 @@ TEST(GENERATED_MESSAGE_TEST_NAME, CopyConstructorWithArenas) {
TestUtil::ExpectAllFieldsSet(*message2_heap);
}
TEST(GENERATED_MESSAGE_TEST_NAME, CopyAssignmentOperator) {
UNITTEST::TestAllTypes message1;
TestUtil::SetAllFields(&message1);
UNITTEST::TestAllTypes message2;
message2 = message1;
TestUtil::ExpectAllFieldsSet(message2);
// Make sure that self-assignment does something sane.
message2.operator=(message2);
TestUtil::ExpectAllFieldsSet(message2);
}
#if !defined(PROTOBUF_TEST_NO_DESCRIPTORS) || PROTOBUF_RTTI
#ifndef PROTOBUF_TEST_NO_DESCRIPTORS
TEST(GENERATED_MESSAGE_TEST_NAME, UpcastCopyFrom) {
// Test the CopyFrom method that takes in the generic const Message&
// parameter.
@ -614,9 +607,6 @@ TEST(GENERATED_MESSAGE_TEST_NAME, UpcastCopyFrom) {
TestUtil::ExpectAllFieldsSet(message2);
}
#endif
#ifndef PROTOBUF_TEST_NO_DESCRIPTORS
TEST(GENERATED_MESSAGE_TEST_NAME, DynamicMessageCopyFrom) {
// Test copying from a DynamicMessage, which must fall back to using
@ -833,7 +823,7 @@ TEST(GENERATED_MESSAGE_TEST_NAME, CamelCaseFieldNames) {
message.mutable_messagefield()->set_c(6);
message.add_repeatedprimitivefield(8);
message.add_repeatedstringfield("qux");
message.add_repeatedstringfield("moo");
message.add_repeatedenumfield(UNITTEST::FOREIGN_BAR);
message.add_repeatedmessagefield()->set_c(15);
@ -843,7 +833,7 @@ TEST(GENERATED_MESSAGE_TEST_NAME, CamelCaseFieldNames) {
EXPECT_EQ(6, message.messagefield().c());
EXPECT_EQ(8, message.repeatedprimitivefield(0));
EXPECT_EQ("qux", message.repeatedstringfield(0));
EXPECT_EQ("moo", message.repeatedstringfield(0));
EXPECT_EQ(UNITTEST::FOREIGN_BAR, message.repeatedenumfield(0));
EXPECT_EQ(15, message.repeatedmessagefield(0).c());
}
@ -879,82 +869,85 @@ TEST(GENERATED_MESSAGE_TEST_NAME, TestEmbedOptimizedForSize) {
}
TEST(GENERATED_MESSAGE_TEST_NAME, TestSpaceUsed) {
UNITTEST::TestAllTypes message1;
// Allocate explicitly on the heap to prevent arena creation.
std::unique_ptr<UNITTEST::TestAllTypes> message1(
Arena::CreateMessage<UNITTEST::TestAllTypes>(nullptr));
// sizeof provides a lower bound on SpaceUsedLong().
EXPECT_LE(sizeof(UNITTEST::TestAllTypes), message1.SpaceUsedLong());
const size_t empty_message_size = message1.SpaceUsedLong();
EXPECT_LE(sizeof(UNITTEST::TestAllTypes), message1->SpaceUsedLong());
const size_t empty_message_size = message1->SpaceUsedLong();
// Setting primitive types shouldn't affect the space used.
message1.set_optional_int32(123);
message1.set_optional_int64(12345);
message1.set_optional_uint32(123);
message1.set_optional_uint64(12345);
EXPECT_EQ(empty_message_size, message1.SpaceUsedLong());
message1->set_optional_int32(123);
message1->set_optional_int64(12345);
message1->set_optional_uint32(123);
message1->set_optional_uint64(12345);
EXPECT_EQ(empty_message_size, message1->SpaceUsedLong());
// On some STL implementations, setting the string to a small value should
// only increase SpaceUsedLong() by the size of a string object, though this
// is not true everywhere.
message1.set_optional_string("abc");
EXPECT_LE(empty_message_size + message1.optional_string().size(),
message1.SpaceUsedLong());
message1->set_optional_string("abc");
EXPECT_LE(empty_message_size + message1->optional_string().size(),
message1->SpaceUsedLong());
// Setting a string to a value larger than the string object itself should
// increase SpaceUsedLong(), because it cannot store the value internally.
message1.set_optional_string(std::string(sizeof(std::string) + 1, 'x'));
int min_expected_increase = message1.optional_string().capacity();
message1->set_optional_string(std::string(sizeof(std::string) + 1, 'x'));
int min_expected_increase = message1->optional_string().capacity();
EXPECT_LE(empty_message_size + min_expected_increase,
message1.SpaceUsedLong());
message1->SpaceUsedLong());
size_t previous_size = message1.SpaceUsedLong();
size_t previous_size = message1->SpaceUsedLong();
// Adding an optional message should increase the size by the size of the
// nested message type. NestedMessage is simple enough (1 int field) that it
// is equal to sizeof(NestedMessage)
message1.mutable_optional_nested_message();
message1->mutable_optional_nested_message();
ASSERT_EQ(sizeof(UNITTEST::TestAllTypes::NestedMessage),
message1.optional_nested_message().SpaceUsedLong());
message1->optional_nested_message().SpaceUsedLong());
EXPECT_EQ(previous_size +
sizeof(UNITTEST::TestAllTypes::NestedMessage),
message1.SpaceUsedLong());
message1->SpaceUsedLong());
}
TEST(GENERATED_MESSAGE_TEST_NAME, TestOneofSpaceUsed) {
UNITTEST::TestOneof2 message1;
EXPECT_LE(sizeof(UNITTEST::TestOneof2), message1.SpaceUsedLong());
// Allocate explicitly on the heap to prevent arena creation.
std::unique_ptr<UNITTEST::TestOneof2> message1(
Arena::CreateMessage<UNITTEST::TestOneof2>(nullptr));
EXPECT_LE(sizeof(UNITTEST::TestOneof2), message1->SpaceUsedLong());
const size_t empty_message_size = message1.SpaceUsedLong();
const size_t empty_message_size = message1->SpaceUsedLong();
// Setting primitive types shouldn't affect the space used.
message1.set_foo_int(123);
message1.set_bar_int(12345);
EXPECT_EQ(empty_message_size, message1.SpaceUsedLong());
message1->set_foo_int(123);
message1->set_bar_int(12345);
EXPECT_EQ(empty_message_size, message1->SpaceUsedLong());
// Setting a string in oneof to a small value should only increase
// SpaceUsedLong() by the size of a string object.
message1.set_foo_string("abc");
EXPECT_LE(empty_message_size + sizeof(std::string), message1.SpaceUsedLong());
message1->set_foo_string("abc");
EXPECT_LE(empty_message_size + sizeof(std::string), message1->SpaceUsedLong());
// Setting a string in oneof to a value larger than the string object itself
// should increase SpaceUsedLong(), because it cannot store the value
// internally.
message1.set_foo_string(std::string(sizeof(std::string) + 1, 'x'));
message1->set_foo_string(std::string(sizeof(std::string) + 1, 'x'));
int min_expected_increase =
message1.foo_string().capacity() + sizeof(std::string);
message1->foo_string().capacity() + sizeof(std::string);
EXPECT_LE(empty_message_size + min_expected_increase,
message1.SpaceUsedLong());
message1->SpaceUsedLong());
// Setting a message in oneof should delete the other fields and increase the
// size by the size of the nested message type. NestedMessage is simple enough
// that it is equal to sizeof(NestedMessage). It may be backed by LazyField,
// increasing space used by LazyField and backing Cord.
message1.mutable_foo_message();
message1->mutable_foo_message();
ASSERT_EQ(sizeof(UNITTEST::TestOneof2::NestedMessage),
message1.foo_message().SpaceUsedLong());
message1->foo_message().SpaceUsedLong());
EXPECT_LE(empty_message_size + sizeof(UNITTEST::TestOneof2::NestedMessage),
message1.SpaceUsedLong());
message1->SpaceUsedLong());
}
#endif // !PROTOBUF_TEST_NO_DESCRIPTORS
TEST(GENERATED_MESSAGE_TEST_NAME, FieldConstantValues) {
UNITTEST::TestRequired message;
EXPECT_EQ(UNITTEST::TestAllTypes_NestedMessage::kBbFieldNumber, 1);
@ -1065,14 +1058,13 @@ TEST(GENERATED_ENUM_TEST_NAME, MinAndMax) {
EXPECT_EQ(12589235, UNITTEST::TestSparseEnum_ARRAYSIZE);
// Make sure we can take the address of _MIN, _MAX and _ARRAYSIZE.
void* null_pointer = 0; // NULL may be integer-type, not pointer-type.
EXPECT_NE(null_pointer, &UNITTEST::TestAllTypes::NestedEnum_MIN);
EXPECT_NE(null_pointer, &UNITTEST::TestAllTypes::NestedEnum_MAX);
EXPECT_NE(null_pointer, &UNITTEST::TestAllTypes::NestedEnum_ARRAYSIZE);
EXPECT_NE(nullptr, &UNITTEST::TestAllTypes::NestedEnum_MIN);
EXPECT_NE(nullptr, &UNITTEST::TestAllTypes::NestedEnum_MAX);
EXPECT_NE(nullptr, &UNITTEST::TestAllTypes::NestedEnum_ARRAYSIZE);
EXPECT_NE(null_pointer, &UNITTEST::ForeignEnum_MIN);
EXPECT_NE(null_pointer, &UNITTEST::ForeignEnum_MAX);
EXPECT_NE(null_pointer, &UNITTEST::ForeignEnum_ARRAYSIZE);
EXPECT_NE(nullptr, &UNITTEST::ForeignEnum_MIN);
EXPECT_NE(nullptr, &UNITTEST::ForeignEnum_MAX);
EXPECT_NE(nullptr, &UNITTEST::ForeignEnum_ARRAYSIZE);
// Make sure we can use _MIN and _MAX as switch cases.
switch (UNITTEST::SPARSE_A) {
@ -1146,14 +1138,14 @@ class GENERATED_SERVICE_TEST_NAME : public testing::Test {
class MockTestService : public UNITTEST::TestService {
public:
MockTestService()
: called_(false),
method_(""),
controller_(NULL),
request_(NULL),
response_(NULL),
done_(NULL) {}
: called_(false),
method_(""),
controller_(nullptr),
request_(nullptr),
response_(nullptr),
done_(nullptr) {}
~MockTestService() {}
~MockTestService() override {}
void Reset() { called_ = false; }
@ -1194,16 +1186,16 @@ class GENERATED_SERVICE_TEST_NAME : public testing::Test {
class MockRpcChannel : public RpcChannel {
public:
MockRpcChannel()
: called_(false),
method_(NULL),
controller_(NULL),
request_(NULL),
response_(NULL),
done_(NULL),
destroyed_(NULL) {}
: called_(false),
method_(nullptr),
controller_(nullptr),
request_(nullptr),
response_(nullptr),
done_(nullptr),
destroyed_(nullptr) {}
~MockRpcChannel() {
if (destroyed_ != NULL) *destroyed_ = true;
~MockRpcChannel() override {
if (destroyed_ != nullptr) *destroyed_ = true;
}
void Reset() { called_ = false; }
@ -1269,8 +1261,8 @@ class GENERATED_SERVICE_TEST_NAME : public testing::Test {
done_(::google::protobuf::NewPermanentCallback(&DoNothing)) {}
void SetUp() override {
ASSERT_TRUE(foo_ != NULL);
ASSERT_TRUE(bar_ != NULL);
ASSERT_TRUE(foo_ != nullptr);
ASSERT_TRUE(bar_ != nullptr);
}
const ServiceDescriptor* descriptor_;
@ -1480,7 +1472,7 @@ TEST_F(OneofTest, SettingOneFieldClearsOthers) {
TestUtil::ExpectAtMostOneFieldSetInOneof(message);
message.set_foo_bytes("qux");
message.set_foo_bytes("moo");
EXPECT_TRUE(message.has_foo_bytes());
TestUtil::ExpectAtMostOneFieldSetInOneof(message);
@ -1488,7 +1480,7 @@ TEST_F(OneofTest, SettingOneFieldClearsOthers) {
EXPECT_TRUE(message.has_foo_enum());
TestUtil::ExpectAtMostOneFieldSetInOneof(message);
message.mutable_foo_message()->set_qux_int(234);
message.mutable_foo_message()->set_moo_int(234);
EXPECT_TRUE(message.has_foo_message());
TestUtil::ExpectAtMostOneFieldSetInOneof(message);
@ -1511,11 +1503,11 @@ TEST_F(OneofTest, EnumCases) {
ExpectEnumCasesWork(message);
message.set_foo_string("foo");
ExpectEnumCasesWork(message);
message.set_foo_bytes("qux");
message.set_foo_bytes("moo");
ExpectEnumCasesWork(message);
message.set_foo_enum(UNITTEST::TestOneof2::FOO);
ExpectEnumCasesWork(message);
message.mutable_foo_message()->set_qux_int(234);
message.mutable_foo_message()->set_moo_int(234);
ExpectEnumCasesWork(message);
message.mutable_foogroup()->set_a(345);
ExpectEnumCasesWork(message);
@ -1565,15 +1557,15 @@ TEST_F(OneofTest, SetString) {
EXPECT_FALSE(message.has_foo_string());
message.set_foo_string("qux", 3);
message.set_foo_string("moo", 3);
EXPECT_TRUE(message.has_foo_string());
EXPECT_EQ(message.foo_string(), "qux");
EXPECT_EQ(message.foo_string(), "moo");
message.clear_foo_string();
EXPECT_FALSE(message.has_foo_string());
message.mutable_foo_string()->assign("quux");
message.mutable_foo_string()->assign("mooo");
EXPECT_TRUE(message.has_foo_string());
EXPECT_EQ(message.foo_string(), "quux");
EXPECT_EQ(message.foo_string(), "mooo");
message.clear_foo_string();
EXPECT_FALSE(message.has_foo_string());
@ -1585,21 +1577,21 @@ TEST_F(OneofTest, SetString) {
}
TEST_F(OneofTest, ReleaseString) {
// Check that release_foo() starts out NULL, and gives us a value
// Check that release_foo() starts out nullptr, and gives us a value
// that we can delete after it's been set.
UNITTEST::TestOneof2 message;
EXPECT_EQ(NULL, message.release_foo_string());
EXPECT_EQ(nullptr, message.release_foo_string());
EXPECT_FALSE(message.has_foo_string());
message.set_foo_string("blah");
EXPECT_TRUE(message.has_foo_string());
std::unique_ptr<std::string> str(message.release_foo_string());
EXPECT_FALSE(message.has_foo_string());
ASSERT_TRUE(str != NULL);
ASSERT_TRUE(str != nullptr);
EXPECT_EQ("blah", *str);
EXPECT_EQ(NULL, message.release_foo_string());
EXPECT_EQ(nullptr, message.release_foo_string());
EXPECT_FALSE(message.has_foo_string());
}
@ -1612,7 +1604,7 @@ TEST_F(OneofTest, SetAllocatedString) {
message.set_foo_string(kHello);
EXPECT_TRUE(message.has_foo_string());
message.set_allocated_foo_string(NULL);
message.set_allocated_foo_string(nullptr);
EXPECT_FALSE(message.has_foo_string());
EXPECT_EQ("", message.foo_string());
@ -1632,7 +1624,7 @@ TEST_F(OneofTest, ArenaSetAllocatedString) {
message->set_foo_string(kHello);
EXPECT_TRUE(message->has_foo_string());
message->set_allocated_foo_string(NULL);
message->set_allocated_foo_string(nullptr);
EXPECT_FALSE(message->has_foo_string());
EXPECT_EQ("", message->foo_string());
@ -1649,32 +1641,32 @@ TEST_F(OneofTest, SetMessage) {
// Unset field returns default instance
EXPECT_EQ(&message.foo_message(),
&UNITTEST::TestOneof2_NestedMessage::default_instance());
EXPECT_EQ(message.foo_message().qux_int(), 0);
EXPECT_EQ(message.foo_message().moo_int(), 0);
message.mutable_foo_message()->set_qux_int(234);
message.mutable_foo_message()->set_moo_int(234);
EXPECT_TRUE(message.has_foo_message());
EXPECT_EQ(message.foo_message().qux_int(), 234);
EXPECT_EQ(message.foo_message().moo_int(), 234);
message.clear_foo_message();
EXPECT_FALSE(message.has_foo_message());
}
TEST_F(OneofTest, ReleaseMessage) {
// Check that release_foo() starts out NULL, and gives us a value
// Check that release_foo() starts out nullptr, and gives us a value
// that we can delete after it's been set.
UNITTEST::TestOneof2 message;
EXPECT_EQ(NULL, message.release_foo_message());
EXPECT_EQ(nullptr, message.release_foo_message());
EXPECT_FALSE(message.has_foo_message());
message.mutable_foo_message()->set_qux_int(1);
message.mutable_foo_message()->set_moo_int(1);
EXPECT_TRUE(message.has_foo_message());
std::unique_ptr<UNITTEST::TestOneof2_NestedMessage> mes(
message.release_foo_message());
EXPECT_FALSE(message.has_foo_message());
ASSERT_TRUE(mes != NULL);
EXPECT_EQ(1, mes->qux_int());
ASSERT_TRUE(mes != nullptr);
EXPECT_EQ(1, mes->moo_int());
EXPECT_EQ(NULL, message.release_foo_message());
EXPECT_EQ(nullptr, message.release_foo_message());
EXPECT_FALSE(message.has_foo_message());
}
@ -1684,22 +1676,22 @@ TEST_F(OneofTest, SetAllocatedMessage) {
EXPECT_FALSE(message.has_foo_message());
message.mutable_foo_message()->set_qux_int(1);
message.mutable_foo_message()->set_moo_int(1);
EXPECT_TRUE(message.has_foo_message());
message.set_allocated_foo_message(NULL);
message.set_allocated_foo_message(nullptr);
EXPECT_FALSE(message.has_foo_message());
EXPECT_EQ(&message.foo_message(),
&UNITTEST::TestOneof2_NestedMessage::default_instance());
message.mutable_foo_message()->set_qux_int(1);
message.mutable_foo_message()->set_moo_int(1);
UNITTEST::TestOneof2_NestedMessage* mes = message.release_foo_message();
ASSERT_TRUE(mes != NULL);
ASSERT_TRUE(mes != nullptr);
EXPECT_FALSE(message.has_foo_message());
message.set_allocated_foo_message(mes);
EXPECT_TRUE(message.has_foo_message());
EXPECT_EQ(1, message.foo_message().qux_int());
EXPECT_EQ(1, message.foo_message().moo_int());
}
@ -1729,7 +1721,7 @@ TEST_F(OneofTest, Defaults) {
EXPECT_EQ(message.foo_enum(), 1);
EXPECT_FALSE(message.has_foo_message());
EXPECT_EQ(message.foo_message().qux_int(), 0);
EXPECT_EQ(message.foo_message().moo_int(), 0);
EXPECT_FALSE(message.has_foogroup());
EXPECT_EQ(message.foogroup().a(), 0);
@ -1773,14 +1765,14 @@ TEST_F(OneofTest, SwapBothHasFields) {
message1.set_foo_string("FOO");
EXPECT_TRUE(message1.has_foo_string());
message2.mutable_foo_message()->set_qux_int(1);
message2.mutable_foo_message()->set_moo_int(1);
EXPECT_TRUE(message2.has_foo_message());
message1.Swap(&message2);
EXPECT_FALSE(message1.has_foo_string());
EXPECT_FALSE(message2.has_foo_message());
EXPECT_TRUE(message1.has_foo_message());
EXPECT_EQ(message1.foo_message().qux_int(), 1);
EXPECT_EQ(message1.foo_message().moo_int(), 1);
EXPECT_TRUE(message2.has_foo_string());
EXPECT_EQ(message2.foo_string(), "FOO");
}
@ -1811,16 +1803,16 @@ TEST_F(OneofTest, CopyFrom) {
TEST_F(OneofTest, CopyAssignmentOperator) {
UNITTEST::TestOneof2 message1;
message1.mutable_foo_message()->set_qux_int(123);
message1.mutable_foo_message()->set_moo_int(123);
EXPECT_TRUE(message1.has_foo_message());
UNITTEST::TestOneof2 message2;
message2 = message1;
EXPECT_EQ(message2.foo_message().qux_int(), 123);
EXPECT_EQ(message2.foo_message().moo_int(), 123);
// Make sure that self-assignment does something sane.
message2 = *&message2; // Avoid -Wself-assign.
EXPECT_EQ(message2.foo_message().qux_int(), 123);
EXPECT_EQ(message2.foo_message().moo_int(), 123);
}
TEST_F(OneofTest, UpcastCopyFrom) {
@ -1875,14 +1867,14 @@ EXPECT_EQ(message2.foo_int(), 123);
{
UNITTEST::TestOneof2 message1, message2;
std::string data;
message1.set_foo_bytes("qux");
message1.set_foo_bytes("moo");
int size = message1.ByteSizeLong();
data.resize(size);
uint8_t* start = reinterpret_cast<uint8_t*>(::google::protobuf::string_as_array(&data));
uint8_t* end = message1.SerializeWithCachedSizesToArray(start);
EXPECT_EQ(size, end - start);
EXPECT_TRUE(message2.ParseFromString(data));
EXPECT_EQ(message2.foo_bytes(), "qux");
EXPECT_EQ(message2.foo_bytes(), "moo");
}
// Enum
@ -1903,14 +1895,14 @@ EXPECT_EQ(message2.foo_int(), 123);
{
UNITTEST::TestOneof2 message1, message2;
std::string data;
message1.mutable_foo_message()->set_qux_int(234);
message1.mutable_foo_message()->set_moo_int(234);
int size = message1.ByteSizeLong();
data.resize(size);
uint8_t* start = reinterpret_cast<uint8_t*>(::google::protobuf::string_as_array(&data));
uint8_t* end = message1.SerializeWithCachedSizesToArray(start);
EXPECT_EQ(size, end - start);
EXPECT_TRUE(message2.ParseFromString(data));
EXPECT_EQ(message2.foo_message().qux_int(), 234);
EXPECT_EQ(message2.foo_message().moo_int(), 234);
}
// Group
@ -1982,7 +1974,7 @@ data.resize(size);
{
UNITTEST::TestOneof2 message1, message2;
std::string data;
message1.set_foo_bytes("qux");
message1.set_foo_bytes("moo");
int size = message1.ByteSizeLong();
data.resize(size);
@ -1996,7 +1988,7 @@ data.resize(size);
}
EXPECT_TRUE(message2.ParseFromString(data));
EXPECT_EQ(message2.foo_bytes(), "qux");
EXPECT_EQ(message2.foo_bytes(), "moo");
}
// Enum
@ -2024,7 +2016,7 @@ data.resize(size);
{
UNITTEST::TestOneof2 message1, message2;
std::string data;
message1.mutable_foo_message()->set_qux_int(234);
message1.mutable_foo_message()->set_moo_int(234);
int size = message1.ByteSizeLong();
data.resize(size);
@ -2038,7 +2030,7 @@ data.resize(size);
}
EXPECT_TRUE(message2.ParseFromString(data));
EXPECT_EQ(message2.foo_message().qux_int(), 234);
EXPECT_EQ(message2.foo_message().moo_int(), 234);
}
// Group
@ -2080,11 +2072,11 @@ TEST_F(OneofTest, MergeFrom) {
EXPECT_EQ(message2.foo_string(), "foo");
message1.set_foo_bytes("qux");
message1.set_foo_bytes("moo");
message2.MergeFrom(message1);
TestUtil::ExpectAtMostOneFieldSetInOneof(message2);
EXPECT_TRUE(message2.has_foo_bytes());
EXPECT_EQ(message2.foo_bytes(), "qux");
EXPECT_EQ(message2.foo_bytes(), "moo");
message1.set_foo_enum(UNITTEST::TestOneof2::FOO);
message2.MergeFrom(message1);
@ -2092,11 +2084,11 @@ TEST_F(OneofTest, MergeFrom) {
EXPECT_TRUE(message2.has_foo_enum());
EXPECT_EQ(message2.foo_enum(), UNITTEST::TestOneof2::FOO);
message1.mutable_foo_message()->set_qux_int(234);
message1.mutable_foo_message()->set_moo_int(234);
message2.MergeFrom(message1);
TestUtil::ExpectAtMostOneFieldSetInOneof(message2);
EXPECT_TRUE(message2.has_foo_message());
EXPECT_EQ(message2.foo_message().qux_int(), 234);
EXPECT_EQ(message2.foo_message().moo_int(), 234);
message1.mutable_foogroup()->set_a(345);
message2.MergeFrom(message1);

5
r5dev/thirdparty/protobuf/compiler/csharp/csharp_bootstrap_unittest.cc vendored
View File

@ -110,13 +110,14 @@ class MockGeneratorContext : public GeneratorContext {
class GenerateAndTest {
public:
GenerateAndTest() {}
void Run(const FileDescriptor* proto_file, std::string file1, std::string file2) {
void Run(const FileDescriptor* proto_file, std::string file1,
std::string file2) {
ASSERT_TRUE(proto_file != NULL) << TestSourceDir();
ASSERT_TRUE(generator_.Generate(proto_file, parameter_,
&context_, &error_));
context_.ExpectFileMatches(file1, file2);
}
void SetParameter(string parameter) {
void SetParameter(std::string parameter) {
parameter_ = parameter;
}

2
r5dev/thirdparty/protobuf/compiler/csharp/csharp_enum_field.cc vendored
View File

@ -109,7 +109,7 @@ void EnumOneofFieldGenerator::GenerateParsingCode(io::Printer* printer) {
printer->Print(
variables_,
"$oneof_name$_ = input.ReadEnum();\n"
"$oneof_name$Case_ = $oneof_property_name$OneofCase.$property_name$;\n");
"$oneof_name$Case_ = $oneof_property_name$OneofCase.$oneof_case_name$;\n");
}
void EnumOneofFieldGenerator::GenerateSerializationCode(io::Printer* printer) {

2
r5dev/thirdparty/protobuf/compiler/csharp/csharp_enum_field.h vendored
View File

@ -31,8 +31,6 @@
#ifndef GOOGLE_PROTOBUF_COMPILER_CSHARP_ENUM_FIELD_H__
#define GOOGLE_PROTOBUF_COMPILER_CSHARP_ENUM_FIELD_H__
#include <string>
#include <thirdparty/protobuf/compiler/code_generator.h>
#include <thirdparty/protobuf/compiler/csharp/csharp_primitive_field.h>

9
r5dev/thirdparty/protobuf/compiler/csharp/csharp_field_base.cc vendored
View File

@ -61,7 +61,7 @@ void FieldGeneratorBase::SetCommonFieldVariables(
part_tag_size /= 2;
}
uint tag = internal::WireFormat::MakeTag(descriptor_);
uint8 tag_array[5];
uint8_t tag_array[5];
io::CodedOutputStream::WriteTagToArray(tag, tag_array);
std::string tag_bytes = StrCat(tag_array[0]);
for (int i = 1; i < part_tag_size; i++) {
@ -130,8 +130,9 @@ void FieldGeneratorBase::SetCommonOneofFieldVariables(
} else {
(*variables)["has_property_check"] =
oneof_name() + "Case_ == " + oneof_property_name() +
"OneofCase." + property_name();
"OneofCase." + oneof_case_name();
}
(*variables)["oneof_case_name"] = oneof_case_name();
(*variables)["oneof_property_name"] = oneof_property_name();
}
@ -187,6 +188,10 @@ void FieldGeneratorBase::AddPublicMemberAttributes(io::Printer* printer) {
WriteGeneratedCodeAttributes(printer);
}
std::string FieldGeneratorBase::oneof_case_name() {
return GetOneofCaseName(descriptor_);
}
std::string FieldGeneratorBase::oneof_property_name() {
return UnderscoresToCamelCase(descriptor_->containing_oneof()->name(), true);
}

1
r5dev/thirdparty/protobuf/compiler/csharp/csharp_field_base.h vendored
View File

@ -85,6 +85,7 @@ class FieldGeneratorBase : public SourceGeneratorBase {
std::map<std::string, std::string>* variables);
std::string oneof_property_name();
std::string oneof_case_name();
std::string oneof_name();
std::string property_name();
std::string name();

15
r5dev/thirdparty/protobuf/compiler/csharp/csharp_generator_unittest.cc vendored
View File

@ -30,14 +30,14 @@
#include <memory>
#include <thirdparty/protobuf/any.pb.h>
#include <thirdparty/protobuf/compiler/command_line_interface.h>
#include <thirdparty/protobuf/compiler/csharp/csharp_helpers.h>
#include <thirdparty/protobuf/descriptor.pb.h>
#include <thirdparty/protobuf/io/zero_copy_stream.h>
#include <thirdparty/protobuf/io/printer.h>
#include <thirdparty/protobuf/testing/googletest.h>
#include <gtest/gtest.h>
#include <thirdparty/protobuf/testing/file.h>
namespace google {
namespace protobuf {
@ -63,6 +63,17 @@ TEST(CSharpEnumValue, PascalCasedPrefixStripping) {
EXPECT_EQ("_2", GetEnumValueName("Foo", "FOO___2"));
}
TEST(DescriptorProtoHelpers, IsDescriptorProto) {
EXPECT_TRUE(IsDescriptorProto(DescriptorProto::descriptor()->file()));
EXPECT_FALSE(IsDescriptorProto(google::protobuf::Any::descriptor()->file()));
}
TEST(DescriptorProtoHelpers, IsDescriptorOptionMessage) {
EXPECT_TRUE(IsDescriptorOptionMessage(FileOptions::descriptor()));
EXPECT_FALSE(IsDescriptorOptionMessage(google::protobuf::Any::descriptor()));
EXPECT_FALSE(IsDescriptorOptionMessage(DescriptorProto::descriptor()));
}
} // namespace
} // namespace csharp
} // namespace compiler

7
r5dev/thirdparty/protobuf/compiler/csharp/csharp_helpers.cc vendored
View File

@ -393,6 +393,13 @@ std::string GetPropertyName(const FieldDescriptor* descriptor) {
return property_name;
}
std::string GetOneofCaseName(const FieldDescriptor* descriptor) {
// The name in a oneof case enum is the same as for the property, but as we always have a "None"
// value as well, we need to reserve that by appending an underscore.
std::string property_name = GetPropertyName(descriptor);
return property_name == "None" ? "None_" : property_name;
}
std::string GetOutputFile(const FileDescriptor* descriptor,
const std::string file_extension,
const bool generate_directories,

23
r5dev/thirdparty/protobuf/compiler/csharp/csharp_helpers.h vendored
View File

@ -87,6 +87,8 @@ std::string GetFieldConstantName(const FieldDescriptor* field);
std::string GetPropertyName(const FieldDescriptor* descriptor);
std::string GetOneofCaseName(const FieldDescriptor* descriptor);
int GetFixedSize(FieldDescriptor::Type type);
std::string UnderscoresToCamelCase(const std::string& input,
@ -130,7 +132,8 @@ uint GetGroupEndTag(const Descriptor* descriptor);
// descriptors etc, for use in the runtime. This is the only type which is
// allowed to use proto2 syntax, and it generates internal classes.
inline bool IsDescriptorProto(const FileDescriptor* descriptor) {
return descriptor->name() == "google/protobuf/descriptor.proto";
return descriptor->name() == "google/protobuf/descriptor.proto" ||
descriptor->name() == "net/proto2/proto/descriptor.proto";
}
// Determines whether the given message is an options message within descriptor.proto.
@ -138,15 +141,15 @@ inline bool IsDescriptorOptionMessage(const Descriptor* descriptor) {
if (!IsDescriptorProto(descriptor->file())) {
return false;
}
const std::string name = descriptor->full_name();
return name == "google.protobuf.FileOptions" ||
name == "google.protobuf.MessageOptions" ||
name == "google.protobuf.FieldOptions" ||
name == "google.protobuf.OneofOptions" ||
name == "google.protobuf.EnumOptions" ||
name == "google.protobuf.EnumValueOptions" ||
name == "google.protobuf.ServiceOptions" ||
name == "google.protobuf.MethodOptions";
const std::string name = descriptor->name();
return name == "FileOptions" ||
name == "MessageOptions" ||
name == "FieldOptions" ||
name == "OneofOptions" ||
name == "EnumOptions" ||
name == "EnumValueOptions" ||
name == "ServiceOptions" ||
name == "MethodOptions";
}
inline bool IsWrapperType(const FieldDescriptor* descriptor) {

4
r5dev/thirdparty/protobuf/compiler/csharp/csharp_map_field.cc vendored
View File

@ -57,9 +57,9 @@ MapFieldGenerator::~MapFieldGenerator() {
void MapFieldGenerator::GenerateMembers(io::Printer* printer) {
const FieldDescriptor* key_descriptor =
descriptor_->message_type()->FindFieldByName("key");
descriptor_->message_type()->map_key();
const FieldDescriptor* value_descriptor =
descriptor_->message_type()->FindFieldByName("value");
descriptor_->message_type()->map_value();
variables_["key_type_name"] = type_name(key_descriptor);
variables_["value_type_name"] = type_name(value_descriptor);
std::unique_ptr<FieldGeneratorBase> key_generator(

2
r5dev/thirdparty/protobuf/compiler/csharp/csharp_map_field.h vendored
View File

@ -31,8 +31,6 @@
#ifndef GOOGLE_PROTOBUF_COMPILER_CSHARP_MAP_FIELD_H__
#define GOOGLE_PROTOBUF_COMPILER_CSHARP_MAP_FIELD_H__
#include <string>
#include <thirdparty/protobuf/compiler/code_generator.h>
#include <thirdparty/protobuf/compiler/csharp/csharp_field_base.h>

14
r5dev/thirdparty/protobuf/compiler/csharp/csharp_message.cc vendored
View File

@ -238,8 +238,8 @@ void MessageGenerator::Generate(io::Printer* printer) {
printer->Print("None = 0,\n");
for (int j = 0; j < oneof->field_count(); j++) {
const FieldDescriptor* field = oneof->field(j);
printer->Print("$field_property_name$ = $index$,\n",
"field_property_name", GetPropertyName(field),
printer->Print("$oneof_case_name$ = $index$,\n",
"oneof_case_name", GetOneofCaseName(field),
"index", StrCat(field->number()));
}
printer->Outdent();
@ -403,10 +403,10 @@ void MessageGenerator::GenerateCloningCode(io::Printer* printer) {
for (int j = 0; j < oneof->field_count(); j++) {
const FieldDescriptor* field = oneof->field(j);
std::unique_ptr<FieldGeneratorBase> generator(CreateFieldGeneratorInternal(field));
vars["field_property_name"] = GetPropertyName(field);
vars["oneof_case_name"] = GetOneofCaseName(field);
printer->Print(
vars,
"case $property_name$OneofCase.$field_property_name$:\n");
"case $property_name$OneofCase.$oneof_case_name$:\n");
printer->Indent();
generator->GenerateCloningCode(printer);
printer->Print("break;\n");
@ -635,10 +635,10 @@ void MessageGenerator::GenerateMergingMethods(io::Printer* printer) {
printer->Indent();
for (int j = 0; j < oneof->field_count(); j++) {
const FieldDescriptor* field = oneof->field(j);
vars["field_property_name"] = GetPropertyName(field);
vars["oneof_case_name"] = GetOneofCaseName(field);
printer->Print(
vars,
"case $property_name$OneofCase.$field_property_name$:\n");
"case $property_name$OneofCase.$oneof_case_name$:\n");
printer->Indent();
std::unique_ptr<FieldGeneratorBase> generator(CreateFieldGeneratorInternal(field));
generator->GenerateMergingCode(printer);
@ -717,7 +717,7 @@ void MessageGenerator::GenerateMainParseLoop(io::Printer* printer, bool use_pars
const FieldDescriptor* field = fields_by_number()[i];
internal::WireFormatLite::WireType wt =
internal::WireFormat::WireTypeForFieldType(field->type());
uint32 tag = internal::WireFormatLite::MakeTag(field->number(), wt);
uint32_t tag = internal::WireFormatLite::MakeTag(field->number(), wt);
// Handle both packed and unpacked repeated fields with the same Read*Array call;
// the two generated cases are the packed and unpacked tags.
// TODO(jonskeet): Check that is_packable is equivalent to

4
r5dev/thirdparty/protobuf/compiler/csharp/csharp_message_field.cc vendored
View File

@ -225,7 +225,7 @@ void MessageOneofFieldGenerator::GenerateMembers(io::Printer* printer) {
" get { return $has_property_check$ ? ($type_name$) $oneof_name$_ : null; }\n"
" set {\n"
" $oneof_name$_ = value;\n"
" $oneof_name$Case_ = value == null ? $oneof_property_name$OneofCase.None : $oneof_property_name$OneofCase.$property_name$;\n"
" $oneof_name$Case_ = value == null ? $oneof_property_name$OneofCase.None : $oneof_property_name$OneofCase.$oneof_case_name$;\n"
" }\n"
"}\n");
if (SupportsPresenceApi(descriptor_)) {
@ -236,7 +236,7 @@ void MessageOneofFieldGenerator::GenerateMembers(io::Printer* printer) {
printer->Print(
variables_,
"$access_level$ bool Has$property_name$ {\n"
" get { return $oneof_name$Case_ == $oneof_property_name$OneofCase.$property_name$; }\n"
" get { return $oneof_name$Case_ == $oneof_property_name$OneofCase.$oneof_case_name$; }\n"
"}\n");
printer->Print(
variables_,

2
r5dev/thirdparty/protobuf/compiler/csharp/csharp_message_field.h vendored
View File

@ -31,8 +31,6 @@
#ifndef GOOGLE_PROTOBUF_COMPILER_CSHARP_MESSAGE_FIELD_H__
#define GOOGLE_PROTOBUF_COMPILER_CSHARP_MESSAGE_FIELD_H__
#include <string>
#include <thirdparty/protobuf/compiler/code_generator.h>
#include <thirdparty/protobuf/compiler/csharp/csharp_field_base.h>

4
r5dev/thirdparty/protobuf/compiler/csharp/csharp_primitive_field.cc vendored
View File

@ -296,7 +296,7 @@ void PrimitiveOneofFieldGenerator::GenerateMembers(io::Printer* printer) {
}
printer->Print(
variables_,
" $oneof_name$Case_ = $oneof_property_name$OneofCase.$property_name$;\n"
" $oneof_name$Case_ = $oneof_property_name$OneofCase.$oneof_case_name$;\n"
" }\n"
"}\n");
if (SupportsPresenceApi(descriptor_)) {
@ -307,7 +307,7 @@ void PrimitiveOneofFieldGenerator::GenerateMembers(io::Printer* printer) {
printer->Print(
variables_,
"$access_level$ bool Has$property_name$ {\n"
" get { return $oneof_name$Case_ == $oneof_property_name$OneofCase.$property_name$; }\n"
" get { return $oneof_name$Case_ == $oneof_property_name$OneofCase.$oneof_case_name$; }\n"
"}\n");
printer->Print(
variables_,

2
r5dev/thirdparty/protobuf/compiler/csharp/csharp_primitive_field.h vendored
View File

@ -31,8 +31,6 @@
#ifndef GOOGLE_PROTOBUF_COMPILER_CSHARP_PRIMITIVE_FIELD_H__
#define GOOGLE_PROTOBUF_COMPILER_CSHARP_PRIMITIVE_FIELD_H__
#include <string>
#include <thirdparty/protobuf/compiler/code_generator.h>
#include <thirdparty/protobuf/compiler/csharp/csharp_field_base.h>

2
r5dev/thirdparty/protobuf/compiler/csharp/csharp_reflection_class.cc vendored
View File

@ -128,7 +128,7 @@ void ReflectionClassGenerator::WriteIntroduction(io::Printer* printer) {
"// Generated by the protocol buffer compiler. DO NOT EDIT!\n"
"// source: $file_name$\n"
"// </auto-generated>\n"
"#pragma warning disable 1591, 0612, 3021\n"
"#pragma warning disable 1591, 0612, 3021, 8981\n"
"#region Designer generated code\n"
"\n"
"using pb = global::Google.Protobuf;\n"

2
r5dev/thirdparty/protobuf/compiler/csharp/csharp_repeated_enum_field.h vendored
View File

@ -31,8 +31,6 @@
#ifndef GOOGLE_PROTOBUF_COMPILER_CSHARP_REPEATED_ENUM_FIELD_H__
#define GOOGLE_PROTOBUF_COMPILER_CSHARP_REPEATED_ENUM_FIELD_H__
#include <string>
#include <thirdparty/protobuf/compiler/code_generator.h>
#include <thirdparty/protobuf/compiler/csharp/csharp_field_base.h>

2
r5dev/thirdparty/protobuf/compiler/csharp/csharp_repeated_message_field.h vendored
View File

@ -31,8 +31,6 @@
#ifndef GOOGLE_PROTOBUF_COMPILER_CSHARP_REPEATED_MESSAGE_FIELD_H__
#define GOOGLE_PROTOBUF_COMPILER_CSHARP_REPEATED_MESSAGE_FIELD_H__
#include <string>
#include <thirdparty/protobuf/compiler/code_generator.h>
#include <thirdparty/protobuf/compiler/csharp/csharp_field_base.h>

2
r5dev/thirdparty/protobuf/compiler/csharp/csharp_repeated_primitive_field.h vendored
View File

@ -31,8 +31,6 @@
#ifndef GOOGLE_PROTOBUF_COMPILER_CSHARP_REPEATED_PRIMITIVE_FIELD_H__
#define GOOGLE_PROTOBUF_COMPILER_CSHARP_REPEATED_PRIMITIVE_FIELD_H__
#include <string>
#include <thirdparty/protobuf/compiler/code_generator.h>
#include <thirdparty/protobuf/compiler/csharp/csharp_field_base.h>

4
r5dev/thirdparty/protobuf/compiler/csharp/csharp_wrapper_field.cc vendored
View File

@ -233,7 +233,7 @@ void WrapperOneofFieldGenerator::GenerateMembers(io::Printer* printer) {
" get { return $has_property_check$ ? ($type_name$) $oneof_name$_ : ($type_name$) null; }\n"
" set {\n"
" $oneof_name$_ = value;\n"
" $oneof_name$Case_ = value == null ? $oneof_property_name$OneofCase.None : $oneof_property_name$OneofCase.$property_name$;\n"
" $oneof_name$Case_ = value == null ? $oneof_property_name$OneofCase.None : $oneof_property_name$OneofCase.$oneof_case_name$;\n"
" }\n"
"}\n");
if (SupportsPresenceApi(descriptor_)) {
@ -244,7 +244,7 @@ void WrapperOneofFieldGenerator::GenerateMembers(io::Printer* printer) {
printer->Print(
variables_,
"$access_level$ bool Has$property_name$ {\n"
" get { return $oneof_name$Case_ == $oneof_property_name$OneofCase.$property_name$; }\n"
" get { return $oneof_name$Case_ == $oneof_property_name$OneofCase.$oneof_case_name$; }\n"
"}\n");
printer->Print(
variables_,

2
r5dev/thirdparty/protobuf/compiler/csharp/csharp_wrapper_field.h vendored
View File

@ -31,8 +31,6 @@
#ifndef GOOGLE_PROTOBUF_COMPILER_CSHARP_WRAPPER_FIELD_H__
#define GOOGLE_PROTOBUF_COMPILER_CSHARP_WRAPPER_FIELD_H__
#include <string>
#include <thirdparty/protobuf/compiler/code_generator.h>
#include <thirdparty/protobuf/compiler/csharp/csharp_field_base.h>

Some files were not shown because too many files have changed in this diff Show More