Chiebot-Mirror
/
protobuf
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Migrate core (sans Parse & Serialize) and extension funcs from `protos` to `hpb`

Browse Source 
This entails:
- CreateMessage
- ClearMessage
- CloneMessage
- DeepCopy

- HasExtension
- ClearExtension
- SetExtension
- GetExtension

PiperOrigin-RevId: 657386985
pull/17611/head
Hong Shin 8 months ago committed by Copybara-Service
parent 7ad56e7cbb
commit 824f6ac9e9
5 changed files with 168 additions and 167 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. 8
      hpb/extension_lock_test.cc
  2. 125
      hpb/hpb.h
  3. 2
      hpb_generator/gen_messages.cc
  4. 190
      hpb_generator/tests/test_generated.cc
  5. 10
      protos/protos.h

8
hpb/extension_lock_test.cc
Unescape View File

@ -36,11 +36,11 @@ std::string GenerateTestData() {
model.set_str1("str");
ThemeExtension extension1;
extension1.set_ext_name("theme");
ABSL_CHECK_OK(::protos::SetExtension(&model, theme, extension1));
ABSL_CHECK_OK(::hpb::SetExtension(&model, theme, extension1));
ThemeExtension extension2;
extension2.set_ext_name("theme_extension");
ABSL_CHECK_OK(::protos::SetExtension(&model, ThemeExtension::theme_extension,
extension2));
ABSL_CHECK_OK(
::hpb::SetExtension(&model, ThemeExtension::theme_extension, extension2));
::upb::Arena arena;
auto bytes = ::protos::Serialize(&model, arena);
ABSL_CHECK_OK(bytes);
@ -62,7 +62,7 @@ void TestConcurrentExtensionAccess(::hpb::ExtensionRegistry registry) {
::protos::Parse<TestModel>(payload, registry).value();
const auto test_main = [&] { EXPECT_EQ("str", parsed_model.str1()); };
const auto test_theme = [&] {
ASSERT_TRUE(::protos::HasExtension(&parsed_model, theme));
ASSERT_TRUE(::hpb::HasExtension(&parsed_model, theme));
auto ext = ::protos::GetExtension(&parsed_model, theme);
ASSERT_OK(ext);
EXPECT_EQ((*ext)->ext_name(), "theme");

125
hpb/hpb.h
Unescape View File

@ -308,65 +308,6 @@ class ExtensionRegistry {
upb_ExtensionRegistry* registry_;
};
} // 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;
template <typename T>
typename T::Proxy CreateMessage(::hpb::Arena& arena) {
return typename T::Proxy(upb_Message_New(T::minitable(), arena.ptr()),
arena.ptr());
}
template <typename T>
void DeepCopy(Ptr<const T> source_message, Ptr<T> target_message) {
static_assert(!std::is_const_v<T>);
::hpb::internal::DeepCopy(
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 ::hpb::internal::PrivateAccess::Proxy<T>(
::hpb::internal::DeepClone(::hpb::internal::GetInternalMsg(message),
T::minitable(), arena),
arena);
}
template <typename T>
void DeepCopy(Ptr<const T> source_message, T* target_message) {
static_assert(!std::is_const_v<T>);
DeepCopy(source_message, Ptr(target_message));
}
template <typename T>
void DeepCopy(const T* source_message, Ptr<T> target_message) {
static_assert(!std::is_const_v<T>);
DeepCopy(Ptr(source_message), target_message);
}
template <typename T>
void DeepCopy(const T* source_message, T* target_message) {
static_assert(!std::is_const_v<T>);
DeepCopy(Ptr(source_message), Ptr(target_message));
}
template <typename T>
void ClearMessage(hpb::internal::PtrOrRaw<T> message) {
auto ptr = Ptr(message);
auto minitable = hpb::internal::GetMiniTable(ptr);
upb_Message_Clear(hpb::internal::GetInternalMsg(ptr), minitable);
}
template <typename T, typename Extendee, typename Extension,
typename = hpb::internal::EnableIfHpbClass<T>>
ABSL_MUST_USE_RESULT bool HasExtension(
@ -452,7 +393,7 @@ template <typename T, typename Extension,
absl::Status SetExtension(
T* message, const ::hpb::internal::ExtensionIdentifier<T, Extension>& id,
const Extension& value) {
return ::protos::SetExtension(Ptr(message), id, value);
return ::hpb::SetExtension(Ptr(message), id, value);
}
template <typename T, typename Extension,
@ -460,8 +401,7 @@ template <typename T, typename Extension,
absl::Status SetExtension(
T* message, const ::hpb::internal::ExtensionIdentifier<T, Extension>& id,
Extension&& value) {
return ::protos::SetExtension(Ptr(message), id,
std::forward<Extension>(value));
return ::hpb::SetExtension(Ptr(message), id, std::forward<Extension>(value));
}
template <typename T, typename Extension,
@ -469,7 +409,7 @@ template <typename T, typename Extension,
absl::Status SetExtension(
T* message, const ::hpb::internal::ExtensionIdentifier<T, Extension>& id,
Ptr<Extension> value) {
return ::protos::SetExtension(Ptr(message), id, value);
return ::hpb::SetExtension(Ptr(message), id, value);
}
template <typename T, typename Extendee, typename Extension,
@ -498,6 +438,65 @@ absl::StatusOr<Ptr<const Extension>> GetExtension(
return GetExtension(Ptr(message), id);
}
template <typename T>
typename T::Proxy CreateMessage(::hpb::Arena& arena) {
return typename T::Proxy(upb_Message_New(T::minitable(), arena.ptr()),
arena.ptr());
}
template <typename T>
typename T::Proxy CloneMessage(Ptr<T> message, upb_Arena* arena) {
return ::hpb::internal::PrivateAccess::Proxy<T>(
::hpb::internal::DeepClone(::hpb::internal::GetInternalMsg(message),
T::minitable(), arena),
arena);
}
template <typename T>
void DeepCopy(Ptr<const T> source_message, Ptr<T> target_message) {
static_assert(!std::is_const_v<T>);
::hpb::internal::DeepCopy(
hpb::internal::GetInternalMsg(target_message),
hpb::internal::GetInternalMsg(source_message), T::minitable(),
static_cast<upb_Arena*>(target_message->GetInternalArena()));
}
template <typename T>
void DeepCopy(Ptr<const T> source_message, T* target_message) {
static_assert(!std::is_const_v<T>);
DeepCopy(source_message, Ptr(target_message));
}
template <typename T>
void DeepCopy(const T* source_message, Ptr<T> target_message) {
static_assert(!std::is_const_v<T>);
DeepCopy(Ptr(source_message), target_message);
}
template <typename T>
void DeepCopy(const T* source_message, T* target_message) {
static_assert(!std::is_const_v<T>);
DeepCopy(Ptr(source_message), Ptr(target_message));
}
template <typename T>
void ClearMessage(hpb::internal::PtrOrRaw<T> message) {
auto ptr = Ptr(message);
auto minitable = hpb::internal::GetMiniTable(ptr);
upb_Message_Clear(hpb::internal::GetInternalMsg(ptr), minitable);
}
} // 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;
template <typename T>
ABSL_MUST_USE_RESULT bool Parse(Ptr<T> message, absl::string_view bytes) {
static_assert(!std::is_const_v<T>);

2
hpb_generator/gen_messages.cc
Unescape View File

@ -297,7 +297,7 @@ 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(::hpb::CreateMessage<$0>(::hpb::Arena& arena));
friend $0::Proxy(::hpb::internal::CreateMessageProxy<$0>(upb_Message*,
upb_Arena*));
friend struct ::hpb::internal::PrivateAccess;

190
hpb_generator/tests/test_generated.cc
Unescape View File

@ -68,13 +68,13 @@ TEST(CppGeneratedCode, MessageEnumValue) {
TEST(CppGeneratedCode, ArenaConstructor) {
::hpb::Arena arena;
auto testModel = ::protos::CreateMessage<TestModel>(arena);
auto testModel = ::hpb::CreateMessage<TestModel>(arena);
EXPECT_EQ(false, testModel.has_b1());
}
TEST(CppGeneratedCode, Booleans) {
::hpb::Arena arena;
auto testModel = ::protos::CreateMessage<TestModel>(arena);
auto testModel = ::hpb::CreateMessage<TestModel>(arena);
EXPECT_FALSE(testModel.b1());
testModel.set_b1(true);
EXPECT_TRUE(testModel.b1());
@ -88,7 +88,7 @@ TEST(CppGeneratedCode, Booleans) {
TEST(CppGeneratedCode, ScalarInt32) {
::hpb::Arena arena;
auto testModel = ::protos::CreateMessage<TestModel>(arena);
auto testModel = ::hpb::CreateMessage<TestModel>(arena);
// Test int32 defaults.
EXPECT_EQ(testModel.value(), 0);
EXPECT_FALSE(testModel.has_value());
@ -131,7 +131,7 @@ TEST(CppGeneratedCode, Strings) {
TEST(CppGeneratedCode, ScalarUInt32) {
::hpb::Arena arena;
auto testModel = ::protos::CreateMessage<TestModel>(arena);
auto testModel = ::hpb::CreateMessage<TestModel>(arena);
// Test defaults.
EXPECT_EQ(testModel.optional_uint32(), 0);
EXPECT_FALSE(testModel.has_optional_uint32());
@ -151,7 +151,7 @@ TEST(CppGeneratedCode, ScalarUInt32) {
TEST(CppGeneratedCode, ScalarInt64) {
::hpb::Arena arena;
auto testModel = ::protos::CreateMessage<TestModel>(arena);
auto testModel = ::hpb::CreateMessage<TestModel>(arena);
// Test defaults.
EXPECT_EQ(testModel.optional_int64(), 0);
EXPECT_FALSE(testModel.has_optional_int64());
@ -175,7 +175,7 @@ TEST(CppGeneratedCode, ScalarInt64) {
TEST(CppGeneratedCode, ScalarFloat) {
::hpb::Arena arena;
auto testModel = ::protos::CreateMessage<TestModel>(arena);
auto testModel = ::hpb::CreateMessage<TestModel>(arena);
// Test defaults.
EXPECT_EQ(testModel.optional_float(), 0.0f);
EXPECT_FALSE(testModel.has_optional_float());
@ -203,7 +203,7 @@ TEST(CppGeneratedCode, ScalarFloat) {
TEST(CppGeneratedCode, ScalarDouble) {
::hpb::Arena arena;
auto testModel = ::protos::CreateMessage<TestModel>(arena);
auto testModel = ::hpb::CreateMessage<TestModel>(arena);
// Test defaults.
EXPECT_EQ(testModel.optional_double(), 0.0);
EXPECT_FALSE(testModel.has_optional_double());
@ -227,7 +227,7 @@ TEST(CppGeneratedCode, ScalarDouble) {
TEST(CppGeneratedCode, Enums) {
::hpb::Arena arena;
auto testModel = ::protos::CreateMessage<TestModel>(arena);
auto testModel = ::hpb::CreateMessage<TestModel>(arena);
// Check enum default value.
EXPECT_EQ(TestModel_Category_IMAGES, 5);
@ -255,7 +255,7 @@ TEST(CppGeneratedCode, Enums) {
TEST(CppGeneratedCode, FieldWithDefaultValue) {
::hpb::Arena arena;
auto testModel = ::protos::CreateMessage<TestModel>(arena);
auto testModel = ::hpb::CreateMessage<TestModel>(arena);
EXPECT_FALSE(testModel.has_int_value_with_default());
EXPECT_EQ(testModel.int_value_with_default(), 65);
@ -270,7 +270,7 @@ TEST(CppGeneratedCode, FieldWithDefaultValue) {
TEST(CppGeneratedCode, OneOfFields) {
::hpb::Arena arena;
auto test_model = ::protos::CreateMessage<TestModel>(arena);
auto test_model = ::hpb::CreateMessage<TestModel>(arena);
EXPECT_FALSE(test_model.has_oneof_member1());
EXPECT_FALSE(test_model.has_oneof_member2());
@ -298,7 +298,7 @@ TEST(CppGeneratedCode, OneOfFields) {
TEST(CppGeneratedCode, Messages) {
::hpb::Arena arena;
auto test_model = ::protos::CreateMessage<TestModel>(arena);
auto test_model = ::hpb::CreateMessage<TestModel>(arena);
EXPECT_EQ(false, test_model.has_child_model_1());
auto child_model = test_model.child_model_1();
EXPECT_EQ(false, child_model->has_child_b1());
@ -322,7 +322,7 @@ TEST(CppGeneratedCode, Messages) {
TEST(CppGeneratedCode, NestedMessages) {
::hpb::Arena arena;
auto test_model = ::protos::CreateMessage<TestModel>(arena);
auto test_model = ::hpb::CreateMessage<TestModel>(arena);
auto nested_child = test_model.nested_child_1();
EXPECT_EQ(0, nested_child->nested_child_name().size());
auto mutable_nested_child = test_model.mutable_nested_child_1();
@ -333,7 +333,7 @@ TEST(CppGeneratedCode, NestedMessages) {
TEST(CppGeneratedCode, RepeatedMessages) {
::hpb::Arena arena;
auto test_model = ::protos::CreateMessage<TestModel>(arena);
auto test_model = ::hpb::CreateMessage<TestModel>(arena);
EXPECT_EQ(0, test_model.child_models_size());
// Should be able to clear repeated field when empty.
test_model.mutable_child_models()->clear();
@ -362,7 +362,7 @@ TEST(CppGeneratedCode, RepeatedMessages) {
TEST(CppGeneratedCode, RepeatedScalar) {
::hpb::Arena arena;
auto test_model = ::protos::CreateMessage<TestModel>(arena);
auto test_model = ::hpb::CreateMessage<TestModel>(arena);
EXPECT_EQ(0, test_model.value_array_size());
// Should be able to clear repeated field when empty.
test_model.mutable_value_array()->clear();
@ -383,7 +383,7 @@ TEST(CppGeneratedCode, RepeatedScalar) {
TEST(CppGeneratedCode, RepeatedFieldClear) {
::hpb::Arena arena;
auto test_model = ::protos::CreateMessage<TestModel>(arena);
auto test_model = ::hpb::CreateMessage<TestModel>(arena);
test_model.mutable_value_array()->push_back(5);
test_model.mutable_value_array()->push_back(16);
test_model.mutable_value_array()->push_back(27);
@ -394,7 +394,7 @@ TEST(CppGeneratedCode, RepeatedFieldClear) {
TEST(CppGeneratedCode, RepeatedFieldProxyForScalars) {
::hpb::Arena arena;
auto test_model = ::protos::CreateMessage<TestModel>(arena);
auto test_model = ::hpb::CreateMessage<TestModel>(arena);
EXPECT_EQ(0, test_model.value_array().size());
EXPECT_EQ(0, test_model.mutable_value_array()->size());
@ -427,7 +427,7 @@ TEST(CppGeneratedCode, RepeatedFieldProxyForScalars) {
TEST(CppGeneratedCode, RepeatedScalarIterator) {
::hpb::Arena arena;
auto test_model = ::protos::CreateMessage<TestModel>(arena);
auto test_model = ::hpb::CreateMessage<TestModel>(arena);
test_model.mutable_value_array()->push_back(5);
test_model.mutable_value_array()->push_back(16);
test_model.mutable_value_array()->push_back(27);
@ -494,7 +494,7 @@ TEST(CppGeneratedCode, RepeatedScalarIterator) {
TEST(CppGeneratedCode, RepeatedFieldProxyForStrings) {
::hpb::Arena arena;
auto test_model = ::protos::CreateMessage<TestModel>(arena);
auto test_model = ::hpb::CreateMessage<TestModel>(arena);
EXPECT_EQ(0, test_model.repeated_string().size());
EXPECT_EQ(0, test_model.mutable_repeated_string()->size());
@ -529,7 +529,7 @@ TEST(CppGeneratedCode, RepeatedFieldProxyForStrings) {
TEST(CppGeneratedCode, RepeatedFieldProxyForMessages) {
::hpb::Arena arena;
auto test_model = ::protos::CreateMessage<TestModel>(arena);
auto test_model = ::hpb::CreateMessage<TestModel>(arena);
EXPECT_EQ(0, test_model.child_models().size());
ChildModel1 child1;
child1.set_child_str1(kTestStr1);
@ -574,7 +574,7 @@ TEST(CppGeneratedCode, RepeatedFieldProxyForMessages) {
TEST(CppGeneratedCode, EmptyRepeatedFieldProxyForMessages) {
::hpb::Arena arena;
auto test_model = ::protos::CreateMessage<TestModel>(arena);
auto test_model = ::hpb::CreateMessage<TestModel>(arena);
EXPECT_EQ(0, test_model.child_models().size());
ChildModel1 child1;
child1.set_child_str1(kTestStr1);
@ -587,7 +587,7 @@ TEST(CppGeneratedCode, EmptyRepeatedFieldProxyForMessages) {
TEST(CppGeneratedCode, RepeatedFieldProxyForMessagesIndexOperator) {
::hpb::Arena arena;
auto test_model = ::protos::CreateMessage<TestModel>(arena);
auto test_model = ::hpb::CreateMessage<TestModel>(arena);
EXPECT_EQ(0, test_model.child_models().size());
ChildModel1 child1;
child1.set_child_str1(kTestStr1);
@ -605,7 +605,7 @@ TEST(CppGeneratedCode, RepeatedFieldProxyForMessagesIndexOperator) {
TEST(CppGeneratedCode, RepeatedStrings) {
::hpb::Arena arena;
auto test_model = ::protos::CreateMessage<TestModel>(arena);
auto test_model = ::hpb::CreateMessage<TestModel>(arena);
EXPECT_EQ(0, test_model.repeated_string_size());
// Should be able to clear repeated field when empty.
test_model.mutable_repeated_string()->clear();
@ -628,11 +628,11 @@ TEST(CppGeneratedCode, MessageMapInt32KeyMessageValue) {
const int key_test_value = 3;
::hpb::Arena arena;
::hpb::Arena child_arena;
auto test_model = ::protos::CreateMessage<TestModel>(arena);
auto test_model = ::hpb::CreateMessage<TestModel>(arena);
EXPECT_EQ(0, test_model.child_map_size());
test_model.clear_child_map();
EXPECT_EQ(0, test_model.child_map_size());
auto child_model1 = ::protos::CreateMessage<ChildModel1>(child_arena);
auto child_model1 = ::hpb::CreateMessage<ChildModel1>(child_arena);
child_model1.set_child_str1("abc");
test_model.set_child_map(key_test_value, child_model1);
auto map_result = test_model.get_child_map(key_test_value);
@ -649,7 +649,7 @@ TEST(CppGeneratedCode, MessageMapInt32KeyMessageValue) {
TEST(CppGeneratedCode, MessageMapStringKeyAndStringValue) {
::hpb::Arena arena;
auto test_model = ::protos::CreateMessage<TestModel>(arena);
auto test_model = ::hpb::CreateMessage<TestModel>(arena);
EXPECT_EQ(0, test_model.str_to_str_map_size());
test_model.clear_str_to_str_map();
EXPECT_EQ(0, test_model.str_to_str_map_size());
@ -665,7 +665,7 @@ TEST(CppGeneratedCode, MessageMapStringKeyAndStringValue) {
TEST(CppGeneratedCode, MessageMapStringKeyAndInt32Value) {
::hpb::Arena arena;
auto test_model = ::protos::CreateMessage<TestModel>(arena);
auto test_model = ::hpb::CreateMessage<TestModel>(arena);
EXPECT_EQ(0, test_model.str_to_int_map_size());
test_model.clear_str_to_int_map();
EXPECT_EQ(0, test_model.str_to_int_map_size());
@ -683,26 +683,26 @@ TEST(CppGeneratedCode, MessageMapStringKeyAndInt32Value) {
TEST(CppGeneratedCode, HasExtension) {
TestModel model;
EXPECT_EQ(false, ::protos::HasExtension(&model, theme));
EXPECT_EQ(false, ::hpb::HasExtension(&model, theme));
}
TEST(CppGeneratedCode, HasExtensionPtr) {
TestModel model;
EXPECT_EQ(false, ::protos::HasExtension(model.recursive_child(), theme));
EXPECT_EQ(false, ::hpb::HasExtension(model.recursive_child(), theme));
}
TEST(CppGeneratedCode, ClearExtensionWithEmptyExtension) {
TestModel model;
EXPECT_EQ(false, ::protos::HasExtension(&model, theme));
::protos::ClearExtension(&model, theme);
EXPECT_EQ(false, ::protos::HasExtension(&model, theme));
EXPECT_EQ(false, ::hpb::HasExtension(&model, theme));
::hpb::ClearExtension(&model, theme);
EXPECT_EQ(false, ::hpb::HasExtension(&model, theme));
}
TEST(CppGeneratedCode, ClearExtensionWithEmptyExtensionPtr) {
TestModel model;
::hpb::Ptr<TestModel> recursive_child = model.mutable_recursive_child();
::protos::ClearExtension(recursive_child, theme);
EXPECT_EQ(false, ::protos::HasExtension(recursive_child, theme));
::hpb::ClearExtension(recursive_child, theme);
EXPECT_EQ(false, ::hpb::HasExtension(recursive_child, theme));
}
TEST(CppGeneratedCode, SetExtension) {
@ -713,12 +713,11 @@ TEST(CppGeneratedCode, SetExtension) {
ThemeExtension extension1;
extension1.set_ext_name("Hello World");
prior_message = ::hpb::internal::GetInternalMsg(&extension1);
EXPECT_EQ(false, ::protos::HasExtension(&model, theme));
EXPECT_EQ(
true,
::protos::SetExtension(&model, theme, std::move(extension1)).ok());
EXPECT_EQ(false, ::hpb::HasExtension(&model, theme));
EXPECT_EQ(true,
::hpb::SetExtension(&model, theme, std::move(extension1)).ok());
}
EXPECT_EQ(true, ::protos::HasExtension(&model, theme));
EXPECT_EQ(true, ::hpb::HasExtension(&model, theme));
auto ext = ::protos::GetExtension(&model, theme);
EXPECT_TRUE(ext.ok());
EXPECT_EQ(::hpb::internal::GetInternalMsg(*ext), prior_message);
@ -726,20 +725,20 @@ TEST(CppGeneratedCode, SetExtension) {
TEST(CppGeneratedCode, SetExtensionWithPtr) {
::hpb::Arena arena_model;
::hpb::Ptr<TestModel> model = ::protos::CreateMessage<TestModel>(arena_model);
::hpb::Ptr<TestModel> model = ::hpb::CreateMessage<TestModel>(arena_model);
void* prior_message;
{
// Use a nested scope to make sure the arenas are fused correctly.
::hpb::Arena arena;
::hpb::Ptr<ThemeExtension> extension1 =
::protos::CreateMessage<ThemeExtension>(arena);
::hpb::CreateMessage<ThemeExtension>(arena);
extension1->set_ext_name("Hello World");
prior_message = ::hpb::internal::GetInternalMsg(extension1);
EXPECT_EQ(false, ::protos::HasExtension(model, theme));
auto res = ::protos::SetExtension(model, theme, extension1);
EXPECT_EQ(false, ::hpb::HasExtension(model, theme));
auto res = ::hpb::SetExtension(model, theme, extension1);
EXPECT_EQ(true, res.ok());
}
EXPECT_EQ(true, ::protos::HasExtension(model, theme));
EXPECT_EQ(true, ::hpb::HasExtension(model, theme));
auto ext = ::protos::GetExtension(model, theme);
EXPECT_TRUE(ext.ok());
EXPECT_NE(::hpb::internal::GetInternalMsg(*ext), prior_message);
@ -748,7 +747,7 @@ TEST(CppGeneratedCode, SetExtensionWithPtr) {
#ifndef _MSC_VER
TEST(CppGeneratedCode, SetExtensionShouldNotCompileForWrongType) {
::hpb::Arena arena;
::hpb::Ptr<TestModel> model = ::protos::CreateMessage<TestModel>(arena);
::hpb::Ptr<TestModel> model = ::hpb::CreateMessage<TestModel>(arena);
ThemeExtension extension1;
ContainerExtension extension2;
@ -756,32 +755,32 @@ TEST(CppGeneratedCode, SetExtensionShouldNotCompileForWrongType) {
return Requires<decltype(model)>(l);
};
EXPECT_TRUE(canSetExtension(
[](auto p) -> decltype(::protos::SetExtension(p, theme, extension1)) {}));
[](auto p) -> decltype(::hpb::SetExtension(p, theme, extension1)) {}));
// Wrong extension value type should fail to compile.
EXPECT_TRUE(!canSetExtension(
[](auto p) -> decltype(::protos::SetExtension(p, theme, extension2)) {}));
[](auto p) -> decltype(::hpb::SetExtension(p, theme, extension2)) {}));
// Wrong extension id with correct extension type should fail to compile.
EXPECT_TRUE(
!canSetExtension([](auto p) -> decltype(::protos::SetExtension(
!canSetExtension([](auto p) -> decltype(::hpb::SetExtension(
p, container_ext, extension1)) {}));
}
#endif
TEST(CppGeneratedCode, SetExtensionWithPtrSameArena) {
::hpb::Arena arena;
::hpb::Ptr<TestModel> model = ::protos::CreateMessage<TestModel>(arena);
::hpb::Ptr<TestModel> model = ::hpb::CreateMessage<TestModel>(arena);
void* prior_message;
{
// Use a nested scope to make sure the arenas are fused correctly.
::hpb::Ptr<ThemeExtension> extension1 =
::protos::CreateMessage<ThemeExtension>(arena);
::hpb::CreateMessage<ThemeExtension>(arena);
extension1->set_ext_name("Hello World");
prior_message = ::hpb::internal::GetInternalMsg(extension1);
EXPECT_EQ(false, ::protos::HasExtension(model, theme));
auto res = ::protos::SetExtension(model, theme, extension1);
EXPECT_EQ(false, ::hpb::HasExtension(model, theme));
auto res = ::hpb::SetExtension(model, theme, extension1);
EXPECT_EQ(true, res.ok());
}
EXPECT_EQ(true, ::protos::HasExtension(model, theme));
EXPECT_EQ(true, ::hpb::HasExtension(model, theme));
auto ext = ::protos::GetExtension(model, theme);
EXPECT_TRUE(ext.ok());
EXPECT_NE(::hpb::internal::GetInternalMsg(*ext), prior_message);
@ -792,16 +791,16 @@ TEST(CppGeneratedCode, SetExtensionFusingFailureShouldCopy) {
char initial_block[1000];
hpb::Arena arena(initial_block, sizeof(initial_block));
hpb::Ptr<TestModel> model = ::protos::CreateMessage<TestModel>(arena);
hpb::Ptr<TestModel> model = ::hpb::CreateMessage<TestModel>(arena);
ThemeExtension extension1;
extension1.set_ext_name("Hello World");
ASSERT_FALSE(
upb_Arena_Fuse(arena.ptr(), ::hpb::internal::GetArena(&extension1)));
EXPECT_FALSE(::protos::HasExtension(model, theme));
auto status = ::protos::SetExtension(model, theme, std::move(extension1));
EXPECT_FALSE(::hpb::HasExtension(model, theme));
auto status = ::hpb::SetExtension(model, theme, std::move(extension1));
EXPECT_TRUE(status.ok());
EXPECT_TRUE(::protos::HasExtension(model, theme));
EXPECT_TRUE(::hpb::HasExtension(model, theme));
EXPECT_TRUE(::protos::GetExtension(model, theme).ok());
}
@ -809,10 +808,10 @@ TEST(CppGeneratedCode, SetExtensionShouldClone) {
TestModel model;
ThemeExtension extension1;
extension1.set_ext_name("Hello World");
EXPECT_EQ(false, ::protos::HasExtension(&model, theme));
EXPECT_EQ(true, ::protos::SetExtension(&model, theme, extension1).ok());
EXPECT_EQ(false, ::hpb::HasExtension(&model, theme));
EXPECT_EQ(true, ::hpb::SetExtension(&model, theme, extension1).ok());
extension1.set_ext_name("Goodbye");
EXPECT_EQ(true, ::protos::HasExtension(&model, theme));
EXPECT_EQ(true, ::hpb::HasExtension(&model, theme));
auto ext = ::protos::GetExtension(&model, theme);
EXPECT_TRUE(ext.ok());
EXPECT_EQ((*ext)->ext_name(), "Hello World");
@ -822,12 +821,11 @@ TEST(CppGeneratedCode, SetExtensionShouldCloneConst) {
TestModel model;
ThemeExtension extension1;
extension1.set_ext_name("Hello World");
EXPECT_EQ(false, ::protos::HasExtension(&model, theme));
EXPECT_EQ(
true,
::protos::SetExtension(&model, theme, std::as_const(extension1)).ok());
EXPECT_EQ(false, ::hpb::HasExtension(&model, theme));
EXPECT_EQ(true,
::hpb::SetExtension(&model, theme, std::as_const(extension1)).ok());
extension1.set_ext_name("Goodbye");
EXPECT_EQ(true, ::protos::HasExtension(&model, theme));
EXPECT_EQ(true, ::hpb::HasExtension(&model, theme));
auto ext = ::protos::GetExtension(&model, theme);
EXPECT_TRUE(ext.ok());
EXPECT_EQ((*ext)->ext_name(), "Hello World");
@ -837,21 +835,19 @@ TEST(CppGeneratedCode, SetExtensionOnMutableChild) {
TestModel model;
ThemeExtension extension1;
extension1.set_ext_name("Hello World");
EXPECT_EQ(false,
::protos::HasExtension(model.mutable_recursive_child(), theme));
EXPECT_EQ(true, ::protos::SetExtension(model.mutable_recursive_child(), theme,
extension1)
EXPECT_EQ(false, ::hpb::HasExtension(model.mutable_recursive_child(), theme));
EXPECT_EQ(true, ::hpb::SetExtension(model.mutable_recursive_child(), theme,
extension1)
.ok());
EXPECT_EQ(true,
::protos::HasExtension(model.mutable_recursive_child(), theme));
EXPECT_EQ(true, ::hpb::HasExtension(model.mutable_recursive_child(), theme));
}
TEST(CppGeneratedCode, GetExtension) {
TestModel model;
ThemeExtension extension1;
extension1.set_ext_name("Hello World");
EXPECT_EQ(false, ::protos::HasExtension(&model, theme));
EXPECT_EQ(true, ::protos::SetExtension(&model, theme, extension1).ok());
EXPECT_EQ(false, ::hpb::HasExtension(&model, theme));
EXPECT_EQ(true, ::hpb::SetExtension(&model, theme, extension1).ok());
EXPECT_EQ("Hello World",
::protos::GetExtension(&model, theme).value()->ext_name());
}
@ -862,10 +858,10 @@ TEST(CppGeneratedCode, GetExtensionOnMutableChild) {
extension1.set_ext_name("Hello World");
::hpb::Ptr<TestModel> mutable_recursive_child =
model.mutable_recursive_child();
EXPECT_EQ(false, ::protos::HasExtension(mutable_recursive_child, theme));
EXPECT_EQ(false, ::hpb::HasExtension(mutable_recursive_child, theme));
EXPECT_EQ(
true,
::protos::SetExtension(mutable_recursive_child, theme, extension1).ok());
::hpb::SetExtension(mutable_recursive_child, theme, extension1).ok());
EXPECT_EQ("Hello World",
::protos::GetExtension(mutable_recursive_child, theme)
.value()
@ -878,10 +874,10 @@ TEST(CppGeneratedCode, GetExtensionOnImmutableChild) {
extension1.set_ext_name("Hello World");
::hpb::Ptr<TestModel> mutable_recursive_child =
model.mutable_recursive_child();
EXPECT_EQ(false, ::protos::HasExtension(mutable_recursive_child, theme));
EXPECT_EQ(false, ::hpb::HasExtension(mutable_recursive_child, theme));
EXPECT_EQ(
true,
::protos::SetExtension(mutable_recursive_child, theme, extension1).ok());
::hpb::SetExtension(mutable_recursive_child, theme, extension1).ok());
::hpb::Ptr<const TestModel> recursive_child = model.recursive_child();
EXPECT_EQ("Hello World",
::protos::GetExtension(recursive_child, theme).value()->ext_name());
@ -899,8 +895,7 @@ TEST(CppGeneratedCode, SerializeUsingArena) {
TEST(CppGeneratedCode, SerializeProxyUsingArena) {
::upb::Arena message_arena;
TestModel::Proxy model_proxy =
::protos::CreateMessage<TestModel>(message_arena);
TestModel::Proxy model_proxy = ::hpb::CreateMessage<TestModel>(message_arena);
model_proxy.set_str1("Hello World");
::upb::Arena arena;
absl::StatusOr<absl::string_view> bytes =
@ -926,7 +921,7 @@ TEST(CppGeneratedCode, Parse) {
model.set_str1("Test123");
ThemeExtension extension1;
extension1.set_ext_name("Hello World");
EXPECT_EQ(true, ::protos::SetExtension(&model, theme, extension1).ok());
EXPECT_EQ(true, ::hpb::SetExtension(&model, theme, extension1).ok());
::upb::Arena arena;
auto bytes = ::protos::Serialize(&model, arena);
EXPECT_EQ(true, bytes.ok());
@ -940,12 +935,11 @@ TEST(CppGeneratedCode, ParseIntoPtrToModel) {
model.set_str1("Test123");
ThemeExtension extension1;
extension1.set_ext_name("Hello World");
EXPECT_EQ(true, ::protos::SetExtension(&model, theme, extension1).ok());
EXPECT_EQ(true, ::hpb::SetExtension(&model, theme, extension1).ok());
::upb::Arena arena;
auto bytes = ::protos::Serialize(&model, arena);
EXPECT_EQ(true, bytes.ok());
::hpb::Ptr<TestModel> parsed_model =
::protos::CreateMessage<TestModel>(arena);
::hpb::Ptr<TestModel> parsed_model = ::hpb::CreateMessage<TestModel>(arena);
EXPECT_TRUE(::protos::Parse(parsed_model, bytes.value()));
EXPECT_EQ("Test123", parsed_model->str1());
// Should return an extension even if we don't pass ExtensionRegistry
@ -958,9 +952,9 @@ TEST(CppGeneratedCode, ParseWithExtensionRegistry) {
model.set_str1("Test123");
ThemeExtension extension1;
extension1.set_ext_name("Hello World");
EXPECT_EQ(true, ::protos::SetExtension(&model, theme, extension1).ok());
EXPECT_EQ(true, ::protos::SetExtension(
&model, ThemeExtension::theme_extension, extension1)
EXPECT_EQ(true, ::hpb::SetExtension(&model, theme, extension1).ok());
EXPECT_EQ(true, ::hpb::SetExtension(&model, ThemeExtension::theme_extension,
extension1)
.ok());
::upb::Arena arena;
auto bytes = ::protos::Serialize(&model, arena);
@ -1129,10 +1123,10 @@ TEST(CppGeneratedCode, ClearSubMessage) {
new_child->set_child_str1("text in child");
ThemeExtension extension1;
extension1.set_ext_name("name in extension");
EXPECT_TRUE(::protos::SetExtension(&model, theme, extension1).ok());
EXPECT_TRUE(::hpb::SetExtension(&model, theme, extension1).ok());
EXPECT_TRUE(model.mutable_child_model_1()->has_child_str1());
// Clear using Ptr<T>
::protos::ClearMessage(model.mutable_child_model_1());
::hpb::ClearMessage(model.mutable_child_model_1());
EXPECT_FALSE(model.mutable_child_model_1()->has_child_str1());
}
@ -1146,14 +1140,14 @@ TEST(CppGeneratedCode, ClearMessage) {
new_child.value()->set_child_str1("text in child");
ThemeExtension extension1;
extension1.set_ext_name("name in extension");
EXPECT_TRUE(::protos::SetExtension(&model, theme, extension1).ok());
EXPECT_TRUE(::hpb::SetExtension(&model, theme, extension1).ok());
// Clear using T*
::protos::ClearMessage(&model);
::hpb::ClearMessage(&model);
// Verify that scalars, repeated fields and extensions are cleared.
EXPECT_FALSE(model.has_int64());
EXPECT_FALSE(model.has_str2());
EXPECT_TRUE(model.child_models().empty());
EXPECT_FALSE(::protos::HasExtension(&model, theme));
EXPECT_FALSE(::hpb::HasExtension(&model, theme));
}
TEST(CppGeneratedCode, CanInvokeClearMessageWithPtr) {
@ -1163,7 +1157,7 @@ TEST(CppGeneratedCode, CanInvokeClearMessageWithPtr) {
auto new_child = model.add_child_models();
// Clear using Ptr<T>
auto ptr = ::hpb::Ptr<TestModel>(&model);
::protos::ClearMessage(ptr);
::hpb::ClearMessage(ptr);
// Successful clear
EXPECT_FALSE(model.has_int64());
}
@ -1174,14 +1168,14 @@ TEST(CppGeneratedCode, CanInvokeClearMessageWithRawPtr) {
model.set_int64(5);
auto new_child = model.add_child_models();
// Clear using T*
::protos::ClearMessage(&model);
::hpb::ClearMessage(&model);
// Successful clear
EXPECT_FALSE(model.has_int64());
}
template <typename T>
bool CanCallClearMessage() {
return Requires<T>([](auto x) -> decltype(::protos::ClearMessage(x)) {});
return Requires<T>([](auto x) -> decltype(::hpb::ClearMessage(x)) {});
}
TEST(CppGeneratedCode, CannotInvokeClearMessageWithConstPtr) {
@ -1204,13 +1198,13 @@ TEST(CppGeneratedCode, DeepCopy) {
new_child.value()->set_child_str1("text in child");
ThemeExtension extension1;
extension1.set_ext_name("name in extension");
EXPECT_TRUE(::protos::SetExtension(&model, theme, extension1).ok());
EXPECT_TRUE(::hpb::SetExtension(&model, theme, extension1).ok());
TestModel target;
target.set_b1(true);
::protos::DeepCopy(&model, &target);
::hpb::DeepCopy(&model, &target);
EXPECT_FALSE(target.b1()) << "Target was not cleared before copying content ";
EXPECT_EQ(target.str2(), "Hello");
EXPECT_TRUE(::protos::HasExtension(&target, theme));
EXPECT_TRUE(::hpb::HasExtension(&target, theme));
}
TEST(CppGeneratedCode, HasExtensionAndRegistry) {
@ -1223,7 +1217,7 @@ TEST(CppGeneratedCode, HasExtensionAndRegistry) {
new_child.value()->set_child_str1("text in child");
ThemeExtension extension1;
extension1.set_ext_name("name in extension");
ASSERT_TRUE(::protos::SetExtension(&source, theme, extension1).ok());
ASSERT_TRUE(::hpb::SetExtension(&source, theme, extension1).ok());
// Now that we have a source model with extension data, serialize.
::hpb::Arena arena;
@ -1232,7 +1226,7 @@ TEST(CppGeneratedCode, HasExtensionAndRegistry) {
// Test with ExtensionRegistry
::hpb::ExtensionRegistry extensions({&theme}, arena);
TestModel parsed_model = ::protos::Parse<TestModel>(data, extensions).value();
EXPECT_TRUE(::protos::HasExtension(&parsed_model, theme));
EXPECT_TRUE(::hpb::HasExtension(&parsed_model, theme));
}
TEST(CppGeneratedCode, FieldNumberConstants) {

10
protos/protos.h
Unescape View File

@ -4,7 +4,6 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd
#ifndef UPB_PROTOS_PROTOS_H_
#define UPB_PROTOS_PROTOS_H_
#include "google/protobuf/hpb/hpb.h"
@ -26,5 +25,14 @@ using hpb::internal::PrivateAccess;
using hpb::internal::Serialize;
using hpb::internal::SetExtension;
} // namespace internal
using hpb::ClearMessage;
using hpb::CloneMessage;
using hpb::CreateMessage;
using hpb::DeepCopy;
using hpb::ClearExtension;
using hpb::GetExtension;
using hpb::HasExtension;
using hpb::SetExtension;
} // namespace protos
#endif

Write Preview
Loading…
Cancel
Save