Chiebot-Mirror
/
protobuf
mirror of https://github.com/protocolbuffers/protobuf.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Fold 80% of `protos::internal` into `hpb::internal`:

Browse Source 
```
- PrivateAccess
- GetInternalMsg
- CreateMessage
- CreateMessageProxy
- GetExtensionNumber
- ExtensionIdentifier
```

PiperOrigin-RevId: 655597227
pull/17576/head
Hong Shin 7 months ago committed by Copybara-Service
parent 29b755fffd
commit 165d2c76ed
9 changed files with 106 additions and 93 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 113
      hpb/hpb.h
  2. 15
      hpb/repeated_field.h
  3. 6
      hpb/repeated_field_iterator.h
  4. 10
      hpb_generator/gen_accessors.cc
  5. 8
      hpb_generator/gen_extensions.cc
  6. 20
      hpb_generator/gen_messages.cc
  7. 6
      hpb_generator/gen_repeated_fields.cc
  8. 12
      hpb_generator/tests/test_generated.cc
  9. 9
      protos/protos.h

113
hpb/hpb.h
Unescape View File

@ -150,21 +150,7 @@ using EnableIfHpbClass = std::enable_if_t<
template <typename T>
using EnableIfMutableProto = std::enable_if_t<!std::is_const<T>::value>;
} // namespace internal
} // namespace hpb
namespace protos {
using hpb::Arena;
using hpb::ExtensionNotFoundError;
using hpb::MessageAllocationError;
using hpb::MessageDecodeError;
using hpb::MessageEncodeError;
using hpb::Ptr;
using hpb::SourceLocation;
class ExtensionRegistry;
namespace internal {
struct PrivateAccess {
template <typename T>
static auto* GetInternalMsg(T&& message) {
@ -182,6 +168,7 @@ struct PrivateAccess {
static auto CreateMessage(upb_Arena* arena) {
return typename T::Proxy(upb_Message_New(T::minitable(), arena), arena);
}
template <typename ExtensionId>
static constexpr uint32_t GetExtensionNumber(const ExtensionId& id) {
return id.number();
@ -245,6 +232,22 @@ class ExtensionIdentifier : public ExtensionMiniTableProvider {
friend class PrivateAccess;
};
} // namespace internal
} // namespace hpb
namespace protos {
using hpb::Arena;
using hpb::ExtensionNotFoundError;
using hpb::MessageAllocationError;
using hpb::MessageDecodeError;
using hpb::MessageEncodeError;
using hpb::Ptr;
using hpb::SourceLocation;
class ExtensionRegistry;
namespace internal {
template <typename T>
upb_Arena* GetArena(Ptr<T> message) {
return static_cast<upb_Arena*>(message->GetInternalArena());
@ -303,15 +306,15 @@ template <typename T>
void DeepCopy(Ptr<const T> source_message, Ptr<T> target_message) {
static_assert(!std::is_const_v<T>);
::protos::internal::DeepCopy(
internal::GetInternalMsg(target_message),
internal::GetInternalMsg(source_message), T::minitable(),
hpb::internal::GetInternalMsg(target_message),
hpb::internal::GetInternalMsg(source_message), T::minitable(),
static_cast<upb_Arena*>(target_message->GetInternalArena()));
}
template <typename T>
typename T::Proxy CloneMessage(Ptr<T> message, upb_Arena* arena) {
return internal::PrivateAccess::Proxy<T>(
::protos::internal::DeepClone(internal::GetInternalMsg(message),
return hpb::internal::PrivateAccess::Proxy<T>(
::protos::internal::DeepClone(hpb::internal::GetInternalMsg(message),
T::minitable(), arena),
arena);
}
@ -338,13 +341,13 @@ template <typename T>
void ClearMessage(hpb::internal::PtrOrRaw<T> message) {
auto ptr = Ptr(message);
auto minitable = internal::GetMiniTable(ptr);
upb_Message_Clear(internal::GetInternalMsg(ptr), minitable);
upb_Message_Clear(hpb::internal::GetInternalMsg(ptr), minitable);
}
class ExtensionRegistry {
public:
ExtensionRegistry(
const std::vector<const ::protos::internal::ExtensionMiniTableProvider*>&
const std::vector<const ::hpb::internal::ExtensionMiniTableProvider*>&
extensions,
const upb::Arena& arena)
: registry_(upb_ExtensionRegistry_New(arena.ptr())) {
@ -370,16 +373,16 @@ template <typename T, typename Extendee, typename Extension,
typename = hpb::internal::EnableIfHpbClass<T>>
ABSL_MUST_USE_RESULT bool HasExtension(
Ptr<T> message,
const ::protos::internal::ExtensionIdentifier<Extendee, Extension>& id) {
const ::hpb::internal::ExtensionIdentifier<Extendee, Extension>& id) {
return ::protos::internal::HasExtensionOrUnknown(
::protos::internal::GetInternalMsg(message), id.mini_table_ext());
::hpb::internal::GetInternalMsg(message), id.mini_table_ext());
}
template <typename T, typename Extendee, typename Extension,
typename = hpb::internal::EnableIfHpbClass<T>>
ABSL_MUST_USE_RESULT bool HasExtension(
const T* message,
const ::protos::internal::ExtensionIdentifier<Extendee, Extension>& id) {
const ::hpb::internal::ExtensionIdentifier<Extendee, Extension>& id) {
return HasExtension(Ptr(message), id);
}
@ -388,17 +391,16 @@ template <typename T, typename Extension,
typename = hpb::internal::EnableIfMutableProto<T>>
void ClearExtension(
Ptr<T> message,
const ::protos::internal::ExtensionIdentifier<T, Extension>& id) {
const ::hpb::internal::ExtensionIdentifier<T, Extension>& id) {
static_assert(!std::is_const_v<T>, "");
upb_Message_ClearExtension(internal::GetInternalMsg(message),
upb_Message_ClearExtension(hpb::internal::GetInternalMsg(message),
id.mini_table_ext());
}
template <typename T, typename Extension,
typename = hpb::internal::EnableIfHpbClass<T>>
void ClearExtension(
T* message,
const ::protos::internal::ExtensionIdentifier<T, Extension>& id) {
T* message, const ::hpb::internal::ExtensionIdentifier<T, Extension>& id) {
ClearExtension(Ptr(message), id);
}
@ -407,13 +409,13 @@ template <typename T, typename Extension,
typename = hpb::internal::EnableIfMutableProto<T>>
absl::Status SetExtension(
Ptr<T> message,
const ::protos::internal::ExtensionIdentifier<T, Extension>& id,
const ::hpb::internal::ExtensionIdentifier<T, Extension>& id,
const Extension& value) {
static_assert(!std::is_const_v<T>);
auto* message_arena = static_cast<upb_Arena*>(message->GetInternalArena());
return ::protos::internal::SetExtension(internal::GetInternalMsg(message),
message_arena, id.mini_table_ext(),
internal::GetInternalMsg(&value));
return ::protos::internal::SetExtension(
hpb::internal::GetInternalMsg(message), message_arena,
id.mini_table_ext(), hpb::internal::GetInternalMsg(&value));
}
template <typename T, typename Extension,
@ -421,13 +423,13 @@ template <typename T, typename Extension,
typename = hpb::internal::EnableIfMutableProto<T>>
absl::Status SetExtension(
Ptr<T> message,
const ::protos::internal::ExtensionIdentifier<T, Extension>& id,
const ::hpb::internal::ExtensionIdentifier<T, Extension>& id,
Ptr<Extension> value) {
static_assert(!std::is_const_v<T>);
auto* message_arena = static_cast<upb_Arena*>(message->GetInternalArena());
return ::protos::internal::SetExtension(internal::GetInternalMsg(message),
message_arena, id.mini_table_ext(),
internal::GetInternalMsg(value));
return ::protos::internal::SetExtension(
hpb::internal::GetInternalMsg(message), message_arena,
id.mini_table_ext(), hpb::internal::GetInternalMsg(value));
}
template <typename T, typename Extension,
@ -435,21 +437,22 @@ template <typename T, typename Extension,
typename = hpb::internal::EnableIfMutableProto<T>>
absl::Status SetExtension(
Ptr<T> message,
const ::protos::internal::ExtensionIdentifier<T, Extension>& id,
const ::hpb::internal::ExtensionIdentifier<T, Extension>& id,
Extension&& value) {
Extension ext = std::move(value);
static_assert(!std::is_const_v<T>);
auto* message_arena = static_cast<upb_Arena*>(message->GetInternalArena());
auto* extension_arena = static_cast<upb_Arena*>(ext.GetInternalArena());
return ::protos::internal::MoveExtension(
internal::GetInternalMsg(message), message_arena, id.mini_table_ext(),
internal::GetInternalMsg(&ext), extension_arena);
hpb::internal::GetInternalMsg(message), message_arena,
id.mini_table_ext(), hpb::internal::GetInternalMsg(&ext),
extension_arena);
}
template <typename T, typename Extension,
typename = hpb::internal::EnableIfHpbClass<T>>
absl::Status SetExtension(
T* message, const ::protos::internal::ExtensionIdentifier<T, Extension>& id,
T* message, const ::hpb::internal::ExtensionIdentifier<T, Extension>& id,
const Extension& value) {
return ::protos::SetExtension(Ptr(message), id, value);
}
@ -457,7 +460,7 @@ absl::Status SetExtension(
template <typename T, typename Extension,
typename = hpb::internal::EnableIfHpbClass<T>>
absl::Status SetExtension(
T* message, const ::protos::internal::ExtensionIdentifier<T, Extension>& id,
T* message, const ::hpb::internal::ExtensionIdentifier<T, Extension>& id,
Extension&& value) {
return ::protos::SetExtension(Ptr(message), id,
std::forward<Extension>(value));
@ -466,7 +469,7 @@ absl::Status SetExtension(
template <typename T, typename Extension,
typename = hpb::internal::EnableIfHpbClass<T>>
absl::Status SetExtension(
T* message, const ::protos::internal::ExtensionIdentifier<T, Extension>& id,
T* message, const ::hpb::internal::ExtensionIdentifier<T, Extension>& id,
Ptr<Extension> value) {
return ::protos::SetExtension(Ptr(message), id, value);
}
@ -475,17 +478,17 @@ template <typename T, typename Extendee, typename Extension,
typename = hpb::internal::EnableIfHpbClass<T>>
absl::StatusOr<Ptr<const Extension>> GetExtension(
Ptr<T> message,
const ::protos::internal::ExtensionIdentifier<Extendee, Extension>& id) {
const ::hpb::internal::ExtensionIdentifier<Extendee, Extension>& id) {
// TODO: Fix const correctness issues.
upb_MessageValue value;
const bool ok = ::protos::internal::GetOrPromoteExtension(
const_cast<upb_Message*>(internal::GetInternalMsg(message)),
const_cast<upb_Message*>(::hpb::internal::GetInternalMsg(message)),
id.mini_table_ext(), ::protos::internal::GetArena(message), &value);
if (!ok) {
return ExtensionNotFoundError(
upb_MiniTableExtension_Number(id.mini_table_ext()));
}
return Ptr<const Extension>(::protos::internal::CreateMessage<Extension>(
return Ptr<const Extension>(::hpb::internal::CreateMessage<Extension>(
(upb_Message*)value.msg_val, ::protos::internal::GetArena(message)));
}
@ -493,18 +496,18 @@ template <typename T, typename Extendee, typename Extension,
typename = hpb::internal::EnableIfHpbClass<T>>
absl::StatusOr<Ptr<const Extension>> GetExtension(
const T* message,
const ::protos::internal::ExtensionIdentifier<Extendee, Extension>& id) {
const ::hpb::internal::ExtensionIdentifier<Extendee, Extension>& id) {
return GetExtension(Ptr(message), id);
}
template <typename T>
ABSL_MUST_USE_RESULT bool Parse(Ptr<T> message, absl::string_view bytes) {
static_assert(!std::is_const_v<T>);
upb_Message_Clear(internal::GetInternalMsg(message),
upb_Message_Clear(::hpb::internal::GetInternalMsg(message),
::protos::internal::GetMiniTable(message));
auto* arena = static_cast<upb_Arena*>(message->GetInternalArena());
return upb_Decode(bytes.data(), bytes.size(),
internal::GetInternalMsg(message),
::hpb::internal::GetInternalMsg(message),
::protos::internal::GetMiniTable(message),
/* extreg= */ nullptr, /* options= */ 0,
arena) == kUpb_DecodeStatus_Ok;
@ -515,11 +518,11 @@ ABSL_MUST_USE_RESULT bool Parse(
Ptr<T> message, absl::string_view bytes,
const ::protos::ExtensionRegistry& extension_registry) {
static_assert(!std::is_const_v<T>);
upb_Message_Clear(internal::GetInternalMsg(message),
upb_Message_Clear(::hpb::internal::GetInternalMsg(message),
::protos::internal::GetMiniTable(message));
auto* arena = static_cast<upb_Arena*>(message->GetInternalArena());
return upb_Decode(bytes.data(), bytes.size(),
internal::GetInternalMsg(message),
::hpb::internal::GetInternalMsg(message),
::protos::internal::GetMiniTable(message),
/* extreg= */
::protos::internal::GetUpbExtensions(extension_registry),
@ -537,11 +540,11 @@ ABSL_MUST_USE_RESULT bool Parse(
template <typename T>
ABSL_MUST_USE_RESULT bool Parse(T* message, absl::string_view bytes) {
static_assert(!std::is_const_v<T>);
upb_Message_Clear(internal::GetInternalMsg(message),
upb_Message_Clear(::hpb::internal::GetInternalMsg(message),
::protos::internal::GetMiniTable(message));
auto* arena = static_cast<upb_Arena*>(message->GetInternalArena());
return upb_Decode(bytes.data(), bytes.size(),
internal::GetInternalMsg(message),
::hpb::internal::GetInternalMsg(message),
::protos::internal::GetMiniTable(message),
/* extreg= */ nullptr, /* options= */ 0,
arena) == kUpb_DecodeStatus_Ok;
@ -582,7 +585,7 @@ template <typename T>
absl::StatusOr<absl::string_view> Serialize(const T* message, upb::Arena& arena,
int options = 0) {
return ::protos::internal::Serialize(
internal::GetInternalMsg(message),
::hpb::internal::GetInternalMsg(message),
::protos::internal::GetMiniTable(message), arena.ptr(), options);
}
@ -590,14 +593,14 @@ template <typename T>
absl::StatusOr<absl::string_view> Serialize(Ptr<T> message, upb::Arena& arena,
int options = 0) {
return ::protos::internal::Serialize(
internal::GetInternalMsg(message),
::hpb::internal::GetInternalMsg(message),
::protos::internal::GetMiniTable(message), arena.ptr(), options);
}
template <typename T, typename Extension>
constexpr uint32_t ExtensionNumber(
internal::ExtensionIdentifier<T, Extension> id) {
return internal::PrivateAccess::GetExtensionNumber(id);
::hpb::internal::ExtensionIdentifier<T, Extension> id) {
return ::hpb::internal::PrivateAccess::GetExtensionNumber(id);
}
} // namespace protos

15
hpb/repeated_field.h
Unescape View File

@ -100,7 +100,7 @@ class RepeatedFieldProxy
// T::CProxy [] operator specialization.
typename T::CProxy operator[](size_t n) const {
upb_MessageValue message_value = upb_Array_Get(this->arr_, n);
return ::protos::internal::CreateMessage<typename std::remove_const_t<T>>(
return ::hpb::internal::CreateMessage<typename std::remove_const_t<T>>(
(upb_Message*)message_value.msg_val, this->arena_);
}
@ -109,8 +109,8 @@ class RepeatedFieldProxy
template <int&... DeductionBlocker, bool b = !kIsConst,
typename = std::enable_if_t<b>>
typename T::Proxy operator[](size_t n) {
return ::protos::internal::CreateMessageProxy<T>(this->GetMessage(n),
this->arena_);
return ::hpb::internal::CreateMessageProxy<T>(this->GetMessage(n),
this->arena_);
}
// Mutable message reference specialization.
@ -119,8 +119,8 @@ class RepeatedFieldProxy
void push_back(const T& t) {
upb_MessageValue message_value;
message_value.msg_val = upb_Message_DeepClone(
PrivateAccess::GetInternalMsg(&t), ::protos::internal::GetMiniTable(&t),
this->arena_);
::hpb::internal::PrivateAccess::GetInternalMsg(&t),
::protos::internal::GetMiniTable(&t), this->arena_);
upb_Array_Append(this->arr_, message_value, this->arena_);
}
@ -129,8 +129,9 @@ class RepeatedFieldProxy
typename = std::enable_if_t<b>>
void push_back(T&& msg) {
upb_MessageValue message_value;
message_value.msg_val = PrivateAccess::GetInternalMsg(&msg);
upb_Arena_Fuse(GetArena(&msg), this->arena_);
message_value.msg_val =
::hpb::internal::PrivateAccess::GetInternalMsg(&msg);
upb_Arena_Fuse(::protos::internal::GetArena(&msg), this->arena_);
upb_Array_Append(this->arr_, message_value, this->arena_);
T moved_msg = std::move(msg);
}

6
hpb/repeated_field_iterator.h
Unescape View File

@ -354,10 +354,10 @@ struct MessageIteratorPolicy {
void AddOffset(ptrdiff_t offset) { arr += offset; }
auto Get() const {
if constexpr (std::is_const_v<T>) {
return ::protos::internal::CreateMessage<
typename std::remove_const_t<T>>(*arr, arena);
return ::hpb::internal::CreateMessage<typename std::remove_const_t<T>>(
*arr, arena);
} else {
return ::protos::internal::CreateMessageProxy<T>(*arr, arena);
return ::hpb::internal::CreateMessageProxy<T>(*arr, arena);
}
}
auto Index() const { return arr; }

10
hpb_generator/gen_accessors.cc
Unescape View File

@ -244,7 +244,7 @@ void WriteAccessorsInSource(const protobuf::Descriptor* desc, Output& output) {
if (!has_$2()) {
return $4::default_instance();
}
return ::protos::internal::CreateMessage<$4>(
return ::hpb::internal::CreateMessage<$4>(
(upb_Message*)($3_$5(msg_)), arena_);
}
)cc",
@ -256,7 +256,7 @@ void WriteAccessorsInSource(const protobuf::Descriptor* desc, Output& output) {
output(
R"cc(
$1 $0::mutable_$2() {
return ::protos::internal::CreateMessageProxy<$4>(
return ::hpb::internal::CreateMessageProxy<$4>(
(upb_Message*)($3_mutable_$5(msg_, $6)), $6);
}
)cc",
@ -295,7 +295,7 @@ void WriteMapAccessorDefinitions(const protobuf::Descriptor* message,
R"cc(
bool $0::set_$1($2 key, $3 value) {
upb_Message* clone = upb_Message_DeepClone(
::protos::internal::PrivateAccess::GetInternalMsg(value), &$9,
::hpb::internal::PrivateAccess::GetInternalMsg(value), &$9,
arena_);
$6return $4_$8_set(msg_, $7, ($5*)clone, arena_);
}
@ -309,7 +309,7 @@ void WriteMapAccessorDefinitions(const protobuf::Descriptor* message,
R"cc(
bool $0::set_$1($2 key, $3 value) {
upb_Message* clone = upb_Message_DeepClone(
::protos::internal::PrivateAccess::GetInternalMsg(value), &$9,
::hpb::internal::PrivateAccess::GetInternalMsg(value), &$9,
arena_);
$6return $4_$8_set(msg_, $7, ($5*)clone, arena_);
}
@ -325,7 +325,7 @@ void WriteMapAccessorDefinitions(const protobuf::Descriptor* message,
$5* msg_value;
$7bool success = $4_$9_get(msg_, $8, &msg_value);
if (success) {
return ::protos::internal::CreateMessage<$6>(UPB_UPCAST(msg_value), arena_);
return ::hpb::internal::CreateMessage<$6>(UPB_UPCAST(msg_value), arena_);
}
return absl::NotFoundError("");
}

8
hpb_generator/gen_extensions.cc
Unescape View File

@ -43,16 +43,16 @@ void WriteExtensionIdentifierHeader(const protobuf::FieldDescriptor* ext,
if (ext->extension_scope()) {
output(
R"cc(
static constexpr ::protos::internal::ExtensionIdentifier<$0, $3> $2{
$4, &$1};
static constexpr ::hpb::internal::ExtensionIdentifier<$0, $3> $2{$4,
&$1};
)cc",
ContainingTypeName(ext), mini_table_name, ext->name(),
CppTypeParameterName(ext), ext->number());
} else {
output(
R"cc(
inline constexpr ::protos::internal::ExtensionIdentifier<$0, $3> $2{
$4, &$1};
inline constexpr ::hpb::internal::ExtensionIdentifier<$0, $3> $2{$4,
&$1};
)cc",
ContainingTypeName(ext), mini_table_name, ext->name(),
CppTypeParameterName(ext), ext->number());

20
hpb_generator/gen_messages.cc
Unescape View File

@ -108,7 +108,7 @@ void WriteModelAccessDeclaration(const protobuf::Descriptor* descriptor,
friend class $2;
friend class $0Proxy;
friend class $0CProxy;
friend struct ::protos::internal::PrivateAccess;
friend struct ::hpb::internal::PrivateAccess;
$1* msg_;
upb_Arena* arena_;
)cc",
@ -238,7 +238,7 @@ void WriteModelPublicDeclaration(
upb_Arena_Fuse(arena_, arena);
}
::hpb::Arena owned_arena_;
friend struct ::protos::internal::PrivateAccess;
friend struct ::hpb::internal::PrivateAccess;
friend Proxy;
friend CProxy;
friend absl::StatusOr<$2>(::protos::Parse<$2>(absl::string_view bytes,
@ -294,9 +294,9 @@ void WriteModelProxyDeclaration(const protobuf::Descriptor* descriptor,
$0Proxy(upb_Message* msg, upb_Arena* arena)
: internal::$0Access(($1*)msg, arena) {}
friend $0::Proxy(::protos::CreateMessage<$0>(::hpb::Arena& arena));
friend $0::Proxy(::protos::internal::CreateMessageProxy<$0>(
upb_Message*, upb_Arena*));
friend struct ::protos::internal::PrivateAccess;
friend $0::Proxy(::hpb::internal::CreateMessageProxy<$0>(upb_Message*,
upb_Arena*));
friend struct ::hpb::internal::PrivateAccess;
friend class RepeatedFieldProxy;
friend class $0CProxy;
friend class $0Access;
@ -347,7 +347,7 @@ void WriteModelCProxyDeclaration(const protobuf::Descriptor* descriptor,
$0CProxy(const upb_Message* msg, upb_Arena* arena)
: internal::$0Access(($1*)msg, arena){};
friend struct ::protos::internal::PrivateAccess;
friend struct ::hpb::internal::PrivateAccess;
friend class RepeatedFieldProxy;
friend class ::hpb::Ptr<$0>;
friend class ::hpb::Ptr<const $0>;
@ -393,12 +393,12 @@ void WriteMessageImplementation(
$0::$0(const CProxy& from) : $0Access() {
arena_ = owned_arena_.ptr();
msg_ = ($1*)::protos::internal::DeepClone(
::protos::internal::GetInternalMsg(&from), &$2, arena_);
::hpb::internal::GetInternalMsg(&from), &$2, arena_);
}
$0::$0(const Proxy& from) : $0(static_cast<const CProxy&>(from)) {}
internal::$0CProxy::$0CProxy($0Proxy m) : $0Access() {
arena_ = m.arena_;
msg_ = ($1*)::protos::internal::GetInternalMsg(&m);
msg_ = ($1*)::hpb::internal::GetInternalMsg(&m);
}
$0& $0::operator=(const $3& from) {
arena_ = owned_arena_.ptr();
@ -408,7 +408,7 @@ void WriteMessageImplementation(
$0& $0::operator=(const CProxy& from) {
arena_ = owned_arena_.ptr();
msg_ = ($1*)::protos::internal::DeepClone(
::protos::internal::GetInternalMsg(&from), &$2, arena_);
::hpb::internal::GetInternalMsg(&from), &$2, arena_);
return *this;
}
)cc",
@ -446,7 +446,7 @@ void WriteMessageImplementation(
output(
R"cc(
::hpb::Ptr<const $0> $0::default_instance() {
return ::protos::internal::CreateMessage<$0>(
return ::hpb::internal::CreateMessage<$0>(
(upb_Message *)_$0_default_instance_.msg,
_$0_default_instance_.arena);
}

6
hpb_generator/gen_repeated_fields.cc
Unescape View File

@ -135,7 +135,7 @@ void WriteRepeatedMessageAccessor(const protobuf::Descriptor* message,
size_t len;
auto* ptr = $3_$5(msg_, &len);
assert(index < len);
return ::protos::internal::CreateMessage<$4>(
return ::hpb::internal::CreateMessage<$4>(
(upb_Message*)*(ptr + index), arena_);
}
)cc",
@ -149,7 +149,7 @@ void WriteRepeatedMessageAccessor(const protobuf::Descriptor* message,
if (!new_msg) {
return ::protos::MessageAllocationError();
}
return ::protos::internal::CreateMessageProxy<$4>((upb_Message*)new_msg, $5);
return ::hpb::internal::CreateMessageProxy<$4>((upb_Message*)new_msg, $5);
}
)cc",
class_name, MessagePtrConstType(field, /* const */ false),
@ -162,7 +162,7 @@ void WriteRepeatedMessageAccessor(const protobuf::Descriptor* message,
size_t len;
auto* ptr = $3_$6(msg_, &len);
assert(index < len);
return ::protos::internal::CreateMessageProxy<$4>(
return ::hpb::internal::CreateMessageProxy<$4>(
(upb_Message*)*(ptr + index), $5);
}
)cc",

12
hpb_generator/tests/test_generated.cc
Unescape View File

@ -712,7 +712,7 @@ TEST(CppGeneratedCode, SetExtension) {
// Use a nested scope to make sure the arenas are fused correctly.
ThemeExtension extension1;
extension1.set_ext_name("Hello World");
prior_message = ::protos::internal::GetInternalMsg(&extension1);
prior_message = ::hpb::internal::GetInternalMsg(&extension1);
EXPECT_EQ(false, ::protos::HasExtension(&model, theme));
EXPECT_EQ(
true,
@ -721,7 +721,7 @@ TEST(CppGeneratedCode, SetExtension) {
EXPECT_EQ(true, ::protos::HasExtension(&model, theme));
auto ext = ::protos::GetExtension(&model, theme);
EXPECT_TRUE(ext.ok());
EXPECT_EQ(::protos::internal::GetInternalMsg(*ext), prior_message);
EXPECT_EQ(::hpb::internal::GetInternalMsg(*ext), prior_message);
}
TEST(CppGeneratedCode, SetExtensionWithPtr) {
@ -734,7 +734,7 @@ TEST(CppGeneratedCode, SetExtensionWithPtr) {
::hpb::Ptr<ThemeExtension> extension1 =
::protos::CreateMessage<ThemeExtension>(arena);
extension1->set_ext_name("Hello World");
prior_message = ::protos::internal::GetInternalMsg(extension1);
prior_message = ::hpb::internal::GetInternalMsg(extension1);
EXPECT_EQ(false, ::protos::HasExtension(model, theme));
auto res = ::protos::SetExtension(model, theme, extension1);
EXPECT_EQ(true, res.ok());
@ -742,7 +742,7 @@ TEST(CppGeneratedCode, SetExtensionWithPtr) {
EXPECT_EQ(true, ::protos::HasExtension(model, theme));
auto ext = ::protos::GetExtension(model, theme);
EXPECT_TRUE(ext.ok());
EXPECT_NE(::protos::internal::GetInternalMsg(*ext), prior_message);
EXPECT_NE(::hpb::internal::GetInternalMsg(*ext), prior_message);
}
#ifndef _MSC_VER
@ -776,7 +776,7 @@ TEST(CppGeneratedCode, SetExtensionWithPtrSameArena) {
::hpb::Ptr<ThemeExtension> extension1 =
::protos::CreateMessage<ThemeExtension>(arena);
extension1->set_ext_name("Hello World");
prior_message = ::protos::internal::GetInternalMsg(extension1);
prior_message = ::hpb::internal::GetInternalMsg(extension1);
EXPECT_EQ(false, ::protos::HasExtension(model, theme));
auto res = ::protos::SetExtension(model, theme, extension1);
EXPECT_EQ(true, res.ok());
@ -784,7 +784,7 @@ TEST(CppGeneratedCode, SetExtensionWithPtrSameArena) {
EXPECT_EQ(true, ::protos::HasExtension(model, theme));
auto ext = ::protos::GetExtension(model, theme);
EXPECT_TRUE(ext.ok());
EXPECT_NE(::protos::internal::GetInternalMsg(*ext), prior_message);
EXPECT_NE(::hpb::internal::GetInternalMsg(*ext), prior_message);
}
TEST(CppGeneratedCode, SetExtensionFusingFailureShouldCopy) {

9
protos/protos.h
Unescape View File

@ -8,4 +8,13 @@
#ifndef UPB_PROTOS_PROTOS_H_
#define UPB_PROTOS_PROTOS_H_
#include "google/protobuf/hpb/hpb.h"
namespace protos {
namespace internal {
using hpb::internal::CreateMessage;
using hpb::internal::CreateMessageProxy;
using hpb::internal::ExtensionIdentifier;
using hpb::internal::GetInternalMsg;
using hpb::internal::PrivateAccess;
} // namespace internal
} // namespace protos
#endif

Write Preview
Loading…
Cancel
Save